mirror of
https://github.com/postgres/postgres.git
synced 2025-07-26 01:22:12 +03:00
Major revision of sort-node handling: push knowledge of query
sort order down into planner, instead of handling it only at the very top level of the planner. This fixes many things. An explicit sort is now avoided if there is a cheaper alternative (typically an indexscan) not only for ORDER BY, but also for the internal sort of GROUP BY. It works even when there is no other reason (such as a WHERE condition) to consider the indexscan. It works for indexes on functions. It works for indexes on functions, backwards. It's just so cool... CAUTION: I have changed the representation of SortClause nodes, therefore THIS UPDATE BREAKS STORED RULES. You will need to initdb.
This commit is contained in:
Tom Lane
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.91 1999/08/16 02:17:41 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.92 1999/08/21 03:48:57 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -456,12 +456,6 @@ _copyAgg(Agg *from)
|
||||
|
||||
CopyPlanFields((Plan *) from, (Plan *) newnode);
|
||||
|
||||
/*
|
||||
* Cannot copy agg list; it must be rebuilt to point to subnodes of
|
||||
* new node.
|
||||
*/
|
||||
set_agg_tlist_references(newnode);
|
||||
|
||||
return newnode;
|
||||
}
|
||||
|
||||
@ -474,8 +468,8 @@ _copyGroupClause(GroupClause *from)
|
||||
{
|
||||
GroupClause *newnode = makeNode(GroupClause);
|
||||
|
||||
newnode->grpOpoid = from->grpOpoid;
|
||||
newnode->tleGroupref = from->tleGroupref;
|
||||
newnode->tleSortGroupRef = from->tleSortGroupRef;
|
||||
newnode->sortop = from->sortop;
|
||||
|
||||
return newnode;
|
||||
}
|
||||
@ -567,12 +561,11 @@ _copyResdom(Resdom *from)
|
||||
newnode->resno = from->resno;
|
||||
newnode->restype = from->restype;
|
||||
newnode->restypmod = from->restypmod;
|
||||
|
||||
if (from->resname != NULL)
|
||||
newnode->resname = pstrdup(from->resname);
|
||||
newnode->ressortgroupref = from->ressortgroupref;
|
||||
newnode->reskey = from->reskey;
|
||||
newnode->reskeyop = from->reskeyop;
|
||||
newnode->resgroupref = from->resgroupref;
|
||||
newnode->resjunk = from->resjunk;
|
||||
|
||||
return newnode;
|
||||
@ -862,8 +855,8 @@ _copyAggref(Aggref *from)
|
||||
newnode->basetype = from->basetype;
|
||||
newnode->aggtype = from->aggtype;
|
||||
Node_Copy(from, newnode, target);
|
||||
newnode->aggno = from->aggno;
|
||||
newnode->usenulls = from->usenulls;
|
||||
newnode->aggno = from->aggno; /* probably not needed */
|
||||
|
||||
return newnode;
|
||||
}
|
||||
@ -1345,8 +1338,8 @@ _copySortClause(SortClause *from)
|
||||
{
|
||||
SortClause *newnode = makeNode(SortClause);
|
||||
|
||||
Node_Copy(from, newnode, resdom);
|
||||
newnode->opoid = from->opoid;
|
||||
newnode->tleSortGroupRef = from->tleSortGroupRef;
|
||||
newnode->sortop = from->sortop;
|
||||
|
||||
return newnode;
|
||||
}
|
||||
@ -1398,33 +1391,29 @@ _copyQuery(Query *from)
|
||||
newnode->isBinary = from->isBinary;
|
||||
newnode->isTemp = from->isTemp;
|
||||
newnode->unionall = from->unionall;
|
||||
if (from->uniqueFlag)
|
||||
newnode->uniqueFlag = pstrdup(from->uniqueFlag);
|
||||
Node_Copy(from, newnode, sortClause);
|
||||
Node_Copy(from, newnode, rtable);
|
||||
Node_Copy(from, newnode, targetList);
|
||||
Node_Copy(from, newnode, qual);
|
||||
|
||||
Node_Copy(from, newnode, groupClause);
|
||||
Node_Copy(from, newnode, havingQual);
|
||||
|
||||
newnode->hasAggs = from->hasAggs;
|
||||
newnode->hasSubLinks = from->hasSubLinks;
|
||||
|
||||
if (from->unionClause)
|
||||
{
|
||||
List *ulist,
|
||||
*temp_list = NIL;
|
||||
Node_Copy(from, newnode, rtable);
|
||||
Node_Copy(from, newnode, targetList);
|
||||
Node_Copy(from, newnode, qual);
|
||||
Node_Copy(from, newnode, rowMark);
|
||||
|
||||
foreach(ulist, from->unionClause)
|
||||
temp_list = lappend(temp_list, copyObject(lfirst(ulist)));
|
||||
newnode->unionClause = temp_list;
|
||||
}
|
||||
if (from->uniqueFlag)
|
||||
newnode->uniqueFlag = pstrdup(from->uniqueFlag);
|
||||
Node_Copy(from, newnode, sortClause);
|
||||
Node_Copy(from, newnode, groupClause);
|
||||
Node_Copy(from, newnode, havingQual);
|
||||
|
||||
/* why is intersectClause missing? */
|
||||
Node_Copy(from, newnode, unionClause);
|
||||
|
||||
Node_Copy(from, newnode, limitOffset);
|
||||
Node_Copy(from, newnode, limitCount);
|
||||
|
||||
Node_Copy(from, newnode, rowMark);
|
||||
/* we do not copy the planner internal fields: base_rel_list,
|
||||
* join_rel_list, query_pathkeys. Not entirely clear if this is right?
|
||||
*/
|
||||
|
||||
return newnode;
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.47 1999/08/16 02:17:41 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.48 1999/08/21 03:48:57 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -34,14 +34,23 @@ _equalResdom(Resdom *a, Resdom *b)
|
||||
return false;
|
||||
if (a->restypmod != b->restypmod)
|
||||
return false;
|
||||
if (strcmp(a->resname, b->resname) != 0)
|
||||
if (a->resname && b->resname)
|
||||
{
|
||||
if (strcmp(a->resname, b->resname) != 0)
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* must both be null to be equal */
|
||||
if (a->resname != b->resname)
|
||||
return false;
|
||||
}
|
||||
if (a->ressortgroupref != b->ressortgroupref)
|
||||
return false;
|
||||
if (a->reskey != b->reskey)
|
||||
return false;
|
||||
if (a->reskeyop != b->reskeyop)
|
||||
return false;
|
||||
if (a->resgroupref != b->resgroupref)
|
||||
return false;
|
||||
/* we ignore resjunk flag ... is this correct? */
|
||||
|
||||
return true;
|
||||
@ -208,10 +217,9 @@ _equalAggref(Aggref *a, Aggref *b)
|
||||
return false;
|
||||
if (!equal(a->target, b->target))
|
||||
return false;
|
||||
if (a->aggno != b->aggno)
|
||||
return false;
|
||||
if (a->usenulls != b->usenulls)
|
||||
return false;
|
||||
/* ignore aggno, which is only a private field for the executor */
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -503,6 +511,14 @@ _equalQuery(Query *a, Query *b)
|
||||
return false;
|
||||
if (a->hasSubLinks != b->hasSubLinks)
|
||||
return false;
|
||||
if (!equal(a->rtable, b->rtable))
|
||||
return false;
|
||||
if (!equal(a->targetList, b->targetList))
|
||||
return false;
|
||||
if (!equal(a->qual, b->qual))
|
||||
return false;
|
||||
if (!equal(a->rowMark, b->rowMark))
|
||||
return false;
|
||||
if (a->uniqueFlag && b->uniqueFlag)
|
||||
{
|
||||
if (strcmp(a->uniqueFlag, b->uniqueFlag) != 0)
|
||||
@ -515,14 +531,6 @@ _equalQuery(Query *a, Query *b)
|
||||
}
|
||||
if (!equal(a->sortClause, b->sortClause))
|
||||
return false;
|
||||
if (!equal(a->rtable, b->rtable))
|
||||
return false;
|
||||
if (!equal(a->targetList, b->targetList))
|
||||
return false;
|
||||
if (!equal(a->qual, b->qual))
|
||||
return false;
|
||||
if (!equal(a->rowMark, b->rowMark))
|
||||
return false;
|
||||
if (!equal(a->groupClause, b->groupClause))
|
||||
return false;
|
||||
if (!equal(a->havingQual, b->havingQual))
|
||||
@ -537,9 +545,9 @@ _equalQuery(Query *a, Query *b)
|
||||
return false;
|
||||
|
||||
/*
|
||||
* We do not check the internal-to-the-planner fields base_rel_list
|
||||
* and join_rel_list. They might not be set yet, and in any case they
|
||||
* should be derivable from the other fields.
|
||||
* We do not check the internal-to-the-planner fields: base_rel_list,
|
||||
* join_rel_list, query_pathkeys. They might not be set yet, and
|
||||
* in any case they should be derivable from the other fields.
|
||||
*/
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.25 1999/08/16 02:17:42 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.26 1999/08/21 03:48:57 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -371,8 +371,6 @@ _freeAgg(Agg *node)
|
||||
{
|
||||
FreePlanFields((Plan *) node);
|
||||
|
||||
freeList(node->aggs);
|
||||
|
||||
pfree(node);
|
||||
}
|
||||
|
||||
@ -964,8 +962,6 @@ _freeRowMark(RowMark *node)
|
||||
static void
|
||||
_freeSortClause(SortClause *node)
|
||||
{
|
||||
freeObject(node->resdom);
|
||||
|
||||
pfree(node);
|
||||
}
|
||||
|
||||
@ -1000,19 +996,22 @@ _freeQuery(Query *node)
|
||||
}
|
||||
if (node->into)
|
||||
pfree(node->into);
|
||||
freeObject(node->rtable);
|
||||
freeObject(node->targetList);
|
||||
freeObject(node->qual);
|
||||
freeObject(node->rowMark);
|
||||
if (node->uniqueFlag)
|
||||
pfree(node->uniqueFlag);
|
||||
|
||||
freeObject(node->sortClause);
|
||||
freeObject(node->rtable);
|
||||
freeObject(node->targetList);
|
||||
freeObject(node->qual);
|
||||
freeObject(node->groupClause);
|
||||
freeObject(node->havingQual);
|
||||
/* why not intersectClause? */
|
||||
freeObject(node->unionClause);
|
||||
freeObject(node->limitOffset);
|
||||
freeObject(node->limitCount);
|
||||
freeObject(node->rowMark);
|
||||
|
||||
/* XXX should we be freeing the planner internal fields? */
|
||||
|
||||
pfree(node);
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/makefuncs.c,v 1.16 1999/07/15 22:39:17 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/makefuncs.c,v 1.17 1999/08/21 03:48:58 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* Creator functions in POSTGRES 4.2 are generated automatically. Most of
|
||||
@ -102,9 +102,12 @@ makeResdom(AttrNumber resno,
|
||||
resdom->restype = restype;
|
||||
resdom->restypmod = restypmod;
|
||||
resdom->resname = resname;
|
||||
/* For historical reasons, ressortgroupref defaults to 0 while
|
||||
* reskey/reskeyop are passed in explicitly. This is pretty silly.
|
||||
*/
|
||||
resdom->ressortgroupref = 0;
|
||||
resdom->reskey = reskey;
|
||||
resdom->reskeyop = reskeyop;
|
||||
resdom->resgroupref = 0;
|
||||
resdom->resjunk = resjunk;
|
||||
return resdom;
|
||||
}
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
*
|
||||
* Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: outfuncs.c,v 1.93 1999/08/16 02:17:42 tgl Exp $
|
||||
* $Id: outfuncs.c,v 1.94 1999/08/21 03:48:58 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* Every (plan) node in POSTGRES has an associated "out" routine which
|
||||
@ -237,18 +237,15 @@ _outQuery(StringInfo str, Query *node)
|
||||
static void
|
||||
_outSortClause(StringInfo str, SortClause *node)
|
||||
{
|
||||
appendStringInfo(str, " SORTCLAUSE :resdom ");
|
||||
_outNode(str, node->resdom);
|
||||
|
||||
appendStringInfo(str, " :opoid %u ", node->opoid);
|
||||
appendStringInfo(str, " SORTCLAUSE :tleSortGroupRef %d :sortop %u ",
|
||||
node->tleSortGroupRef, node->sortop);
|
||||
}
|
||||
|
||||
static void
|
||||
_outGroupClause(StringInfo str, GroupClause *node)
|
||||
{
|
||||
appendStringInfo(str, " GROUPCLAUSE :grpOpoid %u :tleGroupref %d",
|
||||
node->grpOpoid,
|
||||
node->tleGroupref);
|
||||
appendStringInfo(str, " GROUPCLAUSE :tleSortGroupRef %d :sortop %u ",
|
||||
node->tleSortGroupRef, node->sortop);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -482,9 +479,6 @@ _outAgg(StringInfo str, Agg *node)
|
||||
|
||||
appendStringInfo(str, " AGG ");
|
||||
_outPlanInfo(str, (Plan *) node);
|
||||
|
||||
appendStringInfo(str, " :aggs ");
|
||||
_outNode(str, node->aggs);
|
||||
}
|
||||
|
||||
static void
|
||||
@ -549,8 +543,8 @@ _outResdom(StringInfo str, Resdom *node)
|
||||
node->reskey,
|
||||
node->reskeyop);
|
||||
|
||||
appendStringInfo(str, " :resgroupref %d :resjunk %s ",
|
||||
node->resgroupref,
|
||||
appendStringInfo(str, " :ressortgroupref %d :resjunk %s ",
|
||||
node->ressortgroupref,
|
||||
node->resjunk ? "true" : "false");
|
||||
}
|
||||
|
||||
@ -665,8 +659,7 @@ _outAggref(StringInfo str, Aggref *node)
|
||||
node->aggtype);
|
||||
_outNode(str, node->target);
|
||||
|
||||
appendStringInfo(str, ":aggno %d :usenulls %s",
|
||||
node->aggno,
|
||||
appendStringInfo(str, " :usenulls %s ",
|
||||
node->usenulls ? "true" : "false");
|
||||
}
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.72 1999/08/16 02:17:43 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.73 1999/08/21 03:48:58 tgl Exp $
|
||||
*
|
||||
* NOTES
|
||||
* Most of the read functions for plan nodes are tested. (In fact, they
|
||||
@ -184,12 +184,13 @@ _readSortClause()
|
||||
|
||||
local_node = makeNode(SortClause);
|
||||
|
||||
token = lsptok(NULL, &length); /* skip the :resdom */
|
||||
local_node->resdom = nodeRead(true);
|
||||
token = lsptok(NULL, &length); /* skip :tleSortGroupRef */
|
||||
token = lsptok(NULL, &length); /* get tleSortGroupRef */
|
||||
local_node->tleSortGroupRef = strtoul(token, NULL, 10);
|
||||
|
||||
token = lsptok(NULL, &length); /* skip :opoid */
|
||||
token = lsptok(NULL, &length); /* get opoid */
|
||||
local_node->opoid = strtoul(token, NULL, 10);
|
||||
token = lsptok(NULL, &length); /* skip :sortop */
|
||||
token = lsptok(NULL, &length); /* get sortop */
|
||||
local_node->sortop = strtoul(token, NULL, 10);
|
||||
|
||||
return local_node;
|
||||
}
|
||||
@ -207,13 +208,13 @@ _readGroupClause()
|
||||
|
||||
local_node = makeNode(GroupClause);
|
||||
|
||||
token = lsptok(NULL, &length); /* skip :grpOpoid */
|
||||
token = lsptok(NULL, &length); /* get grpOpoid */
|
||||
local_node->grpOpoid = strtoul(token, NULL, 10);
|
||||
token = lsptok(NULL, &length); /* skip :tleSortGroupRef */
|
||||
token = lsptok(NULL, &length); /* get tleSortGroupRef */
|
||||
local_node->tleSortGroupRef = strtoul(token, NULL, 10);
|
||||
|
||||
token = lsptok(NULL, &length); /* skip :tleGroupref */
|
||||
token = lsptok(NULL, &length); /* get tleGroupref */
|
||||
local_node->tleGroupref = strtoul(token, NULL, 10);
|
||||
token = lsptok(NULL, &length); /* skip :sortop */
|
||||
token = lsptok(NULL, &length); /* get sortop */
|
||||
local_node->sortop = strtoul(token, NULL, 10);
|
||||
|
||||
return local_node;
|
||||
}
|
||||
@ -600,15 +601,10 @@ static Agg *
|
||||
_readAgg()
|
||||
{
|
||||
Agg *local_node;
|
||||
char *token;
|
||||
int length;
|
||||
|
||||
local_node = makeNode(Agg);
|
||||
_getPlan((Plan *) local_node);
|
||||
|
||||
token = lsptok(NULL, &length); /* eat :agg */
|
||||
local_node->aggs = nodeRead(true); /* now read it */
|
||||
|
||||
return local_node;
|
||||
}
|
||||
|
||||
@ -712,9 +708,9 @@ _readResdom()
|
||||
token = lsptok(NULL, &length); /* get reskeyop */
|
||||
local_node->reskeyop = (Oid) atol(token);
|
||||
|
||||
token = lsptok(NULL, &length); /* eat :resgroupref */
|
||||
token = lsptok(NULL, &length); /* get resgroupref */
|
||||
local_node->resgroupref = strtoul(token, NULL, 10);
|
||||
token = lsptok(NULL, &length); /* eat :ressortgroupref */
|
||||
token = lsptok(NULL, &length); /* get ressortgroupref */
|
||||
local_node->ressortgroupref = strtoul(token, NULL, 10);
|
||||
|
||||
token = lsptok(NULL, &length); /* eat :resjunk */
|
||||
token = lsptok(NULL, &length); /* get resjunk */
|
||||
@ -1163,10 +1159,6 @@ _readAggref()
|
||||
token = lsptok(NULL, &length); /* eat :target */
|
||||
local_node->target = nodeRead(true); /* now read it */
|
||||
|
||||
token = lsptok(NULL, &length); /* eat :aggno */
|
||||
token = lsptok(NULL, &length); /* get aggno */
|
||||
local_node->aggno = atoi(token);
|
||||
|
||||
token = lsptok(NULL, &length); /* eat :usenulls */
|
||||
token = lsptok(NULL, &length); /* get usenulls */
|
||||
local_node->usenulls = (token[0] == 't') ? true : false;
|
||||
|
||||
Reference in New Issue
Block a user