rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

When testing whether a sub-plan can do projection, use a general-purpose 

check instead of hardwiring assumptions that only certain plan node types
can appear at the places where we are testing.  This was always a pretty
fragile assumption, and it turns out to be broken in 7.4 for certain cases
involving IN-subselect tests that need type coercion.
Also, modify code that builds finished Plan tree so that node types that
don't do projection always copy their input node's targetlist, rather than
having the tlist passed in from the caller.  The old method makes it too
easy to write broken code that thinks it can modify the tlist when it
cannot.
This commit is contained in:
Tom Lane 2004-01-18 00:50:03 +00:00
parent de816a03c4
commit 6bdfde9a77
4 changed files with 81 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
src/backend/optimizer/plan/createplan.c
View File

@ -10,7 +10,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.166 2004/01/07 18:56:26 neilc Exp $ * $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.167 2004/01/18 00:50:02 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -97,13 +97,13 @@ static HashJoin *make_hashjoin(List *tlist,
List *hashclauses, List *hashclauses,
Plan *lefttree, Plan *righttree, Plan *lefttree, Plan *righttree,
JoinType jointype); JoinType jointype);
static Hash *make_hash(List *tlist, Plan *lefttree); static Hash *make_hash(Plan *lefttree);
static MergeJoin *make_mergejoin(List *tlist, static MergeJoin *make_mergejoin(List *tlist,
List *joinclauses, List *otherclauses, List *joinclauses, List *otherclauses,
List *mergeclauses, List *mergeclauses,
Plan *lefttree, Plan *righttree, Plan *lefttree, Plan *righttree,
JoinType jointype); JoinType jointype);
static Sort *make_sort(Query *root, List *tlist, Plan *lefttree, int numCols, static Sort *make_sort(Query *root, Plan *lefttree, int numCols,
AttrNumber *sortColIdx, Oid *sortOperators); AttrNumber *sortColIdx, Oid *sortOperators);
static Sort *make_sort_from_pathkeys(Query *root, Plan *lefttree, static Sort *make_sort_from_pathkeys(Query *root, Plan *lefttree,
Relids relids, List *pathkeys); Relids relids, List *pathkeys);
@ -492,7 +492,7 @@ create_material_plan(Query *root, MaterialPath *best_path)
/* We don't want any excess columns in the materialized tuples */ /* We don't want any excess columns in the materialized tuples */
disuse_physical_tlist(subplan, best_path->subpath); disuse_physical_tlist(subplan, best_path->subpath);
plan = make_material(subplan->targetlist, subplan); plan = make_material(subplan);
copy_path_costsize(&plan->plan, (Path *) best_path); copy_path_costsize(&plan->plan, (Path *) best_path);
@ -518,7 +518,6 @@ create_unique_plan(Query *root, UniquePath *best_path)
List *newtlist; List *newtlist;
int nextresno; int nextresno;
bool newitems; bool newitems;
List *my_tlist;
List *l; List *l;
subplan = create_plan(root, best_path->subpath); subplan = create_plan(root, best_path->subpath);
@ -596,11 +595,8 @@ create_unique_plan(Query *root, UniquePath *best_path)
/* /*
* If the top plan node can't do projections, we need to add a * If the top plan node can't do projections, we need to add a
* Result node to help it along. * Result node to help it along.
*
* Currently, the only non-projection-capable plan type we can see
* here is Append.
*/ */
if (IsA(subplan, Append)) if (!is_projection_capable_plan(subplan))
subplan = (Plan *) make_result(newtlist, NULL, subplan); subplan = (Plan *) make_result(newtlist, NULL, subplan);
else else
subplan->targetlist = newtlist; subplan->targetlist = newtlist;
@ -610,9 +606,6 @@ create_unique_plan(Query *root, UniquePath *best_path)
if (best_path->umethod == UNIQUE_PATH_NOOP) if (best_path->umethod == UNIQUE_PATH_NOOP)
return subplan; return subplan;
/* Copy tlist again to make one we can put sorting labels on */
my_tlist = copyObject(subplan->targetlist);
if (best_path->umethod == UNIQUE_PATH_HASH) if (best_path->umethod == UNIQUE_PATH_HASH)
{ {
long numGroups; long numGroups;
@ -620,7 +613,7 @@ create_unique_plan(Query *root, UniquePath *best_path)
numGroups = (long) Min(best_path->rows, (double) LONG_MAX); numGroups = (long) Min(best_path->rows, (double) LONG_MAX);
plan = (Plan *) make_agg(root, plan = (Plan *) make_agg(root,
my_tlist, copyObject(subplan->targetlist),
NIL, NIL,
AGG_HASHED, AGG_HASHED,
numGroupCols, numGroupCols,
@ -637,15 +630,15 @@ create_unique_plan(Query *root, UniquePath *best_path)
{ {
TargetEntry *tle; TargetEntry *tle;
tle = get_tle_by_resno(my_tlist, groupColIdx[groupColPos]); tle = get_tle_by_resno(subplan->targetlist,
groupColIdx[groupColPos]);
Assert(tle != NULL); Assert(tle != NULL);
sortList = addTargetToSortList(NULL, tle, sortList = addTargetToSortList(NULL, tle,
sortList, my_tlist, sortList, subplan->targetlist,
SORTBY_ASC, NIL, false); SORTBY_ASC, NIL, false);
} }
plan = (Plan *) make_sort_from_sortclauses(root, my_tlist, plan = (Plan *) make_sort_from_sortclauses(root, sortList, subplan);
subplan, sortList); plan = (Plan *) make_unique(plan, sortList);
plan = (Plan *) make_unique(my_tlist, plan, sortList);
} }
/* Adjust output size estimate (other fields should be OK already) */ /* Adjust output size estimate (other fields should be OK already) */
@ -1145,8 +1138,7 @@ create_hashjoin_plan(Query *root,
/* /*
* Build the hash node and hash join node. * Build the hash node and hash join node.
*/ */
hash_plan = make_hash(inner_plan->targetlist, hash_plan = make_hash(inner_plan);
inner_plan);
join_plan = make_hashjoin(tlist, join_plan = make_hashjoin(tlist,
joinclauses, joinclauses,
otherclauses, otherclauses,
@ -1735,7 +1727,7 @@ make_hashjoin(List *tlist,
} }
static Hash * static Hash *
make_hash(List *tlist, Plan *lefttree) make_hash(Plan *lefttree)
{ {
Hash *node = makeNode(Hash); Hash *node = makeNode(Hash);
Plan *plan = &node->plan; Plan *plan = &node->plan;
@ -1747,7 +1739,7 @@ make_hash(List *tlist, Plan *lefttree)
* input plan; this only affects EXPLAIN display not decisions. * input plan; this only affects EXPLAIN display not decisions.
*/ */
plan->startup_cost = plan->total_cost; plan->startup_cost = plan->total_cost;
plan->targetlist = tlist; plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL; plan->qual = NIL;
plan->lefttree = lefttree; plan->lefttree = lefttree;
plan->righttree = NULL; plan->righttree = NULL;
@ -1785,7 +1777,7 @@ make_mergejoin(List *tlist,
* Caller must have built the sortColIdx and sortOperators arrays already. * Caller must have built the sortColIdx and sortOperators arrays already.
*/ */
static Sort * static Sort *
make_sort(Query *root, List *tlist, Plan *lefttree, int numCols, make_sort(Query *root, Plan *lefttree, int numCols,
AttrNumber *sortColIdx, Oid *sortOperators) AttrNumber *sortColIdx, Oid *sortOperators)
{ {
Sort *node = makeNode(Sort); Sort *node = makeNode(Sort);
@ -1799,7 +1791,7 @@ make_sort(Query *root, List *tlist, Plan *lefttree, int numCols,
lefttree->plan_width); lefttree->plan_width);
plan->startup_cost = sort_path.startup_cost; plan->startup_cost = sort_path.startup_cost;
plan->total_cost = sort_path.total_cost; plan->total_cost = sort_path.total_cost;
plan->targetlist = tlist; plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL; plan->qual = NIL;
plan->lefttree = lefttree; plan->lefttree = lefttree;
plan->righttree = NULL; plan->righttree = NULL;
@ -1862,7 +1854,6 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
Relids relids, List *pathkeys) Relids relids, List *pathkeys)
{ {
List *tlist = lefttree->targetlist; List *tlist = lefttree->targetlist;
List *sort_tlist;
List *i; List *i;
int numsortkeys; int numsortkeys;
AttrNumber *sortColIdx; AttrNumber *sortColIdx;
@ -1916,11 +1907,8 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
/* /*
* Do we need to insert a Result node? * Do we need to insert a Result node?
*
* Currently, the only non-projection-capable plan type we can
* see here is Append.
*/ */
if (IsA(lefttree, Append)) if (!is_projection_capable_plan(lefttree))
{ {
tlist = copyObject(tlist); tlist = copyObject(tlist);
lefttree = (Plan *) make_result(tlist, NULL, lefttree); lefttree = (Plan *) make_result(tlist, NULL, lefttree);
@ -1952,10 +1940,7 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
Assert(numsortkeys > 0); Assert(numsortkeys > 0);
/* Give Sort node its own copy of the tlist (still necessary?) */ return make_sort(root, lefttree, numsortkeys,
sort_tlist = copyObject(tlist);
return make_sort(root, sort_tlist, lefttree, numsortkeys,
sortColIdx, sortOperators); sortColIdx, sortOperators);
} }
@ -1963,15 +1948,13 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
* make_sort_from_sortclauses * make_sort_from_sortclauses
* Create sort plan to sort according to given sortclauses * Create sort plan to sort according to given sortclauses
* *
* 'tlist' is the targetlist
* 'lefttree' is the node which yields input tuples
* 'sortcls' is a list of SortClauses * 'sortcls' is a list of SortClauses
* 'lefttree' is the node which yields input tuples
*/ */
Sort * Sort *
make_sort_from_sortclauses(Query *root, List *tlist, make_sort_from_sortclauses(Query *root, List *sortcls, Plan *lefttree)
Plan *lefttree, List *sortcls)
{ {
List *sort_tlist; List *sub_tlist = lefttree->targetlist;
List *i; List *i;
int numsortkeys; int numsortkeys;
AttrNumber *sortColIdx; AttrNumber *sortColIdx;
@ -1987,24 +1970,20 @@ make_sort_from_sortclauses(Query *root, List *tlist,
foreach(i, sortcls) foreach(i, sortcls)
{ {
SortClause *sortcl = (SortClause *) lfirst(i); SortClause *sortcl = (SortClause *) lfirst(i);
TargetEntry *tle = get_sortgroupclause_tle(sortcl, tlist); TargetEntry *tle = get_sortgroupclause_tle(sortcl, sub_tlist);
Resdom *resdom = tle->resdom;
/* /*
* Check for the possibility of duplicate order-by clauses --- the * Check for the possibility of duplicate order-by clauses --- the
* parser should have removed 'em, but no point in sorting * parser should have removed 'em, but no point in sorting
* redundantly. * redundantly.
*/ */
numsortkeys = add_sort_column(resdom->resno, sortcl->sortop, numsortkeys = add_sort_column(tle->resdom->resno, sortcl->sortop,
numsortkeys, sortColIdx, sortOperators); numsortkeys, sortColIdx, sortOperators);
} }
Assert(numsortkeys > 0); Assert(numsortkeys > 0);
/* Give Sort node its own copy of the tlist (still necessary?) */ return make_sort(root, lefttree, numsortkeys,
sort_tlist = copyObject(tlist);
return make_sort(root, sort_tlist, lefttree, numsortkeys,
sortColIdx, sortOperators); sortColIdx, sortOperators);
} }
@ -2028,7 +2007,6 @@ make_sort_from_groupcols(Query *root,
Plan *lefttree) Plan *lefttree)
{ {
List *sub_tlist = lefttree->targetlist; List *sub_tlist = lefttree->targetlist;
List *sort_tlist;
int grpno = 0; int grpno = 0;
List *i; List *i;
int numsortkeys; int numsortkeys;
@ -2046,35 +2024,31 @@ make_sort_from_groupcols(Query *root,
{ {
GroupClause *grpcl = (GroupClause *) lfirst(i); GroupClause *grpcl = (GroupClause *) lfirst(i);
TargetEntry *tle = get_tle_by_resno(sub_tlist, grpColIdx[grpno]); TargetEntry *tle = get_tle_by_resno(sub_tlist, grpColIdx[grpno]);
Resdom *resdom = tle->resdom;
/* /*
* Check for the possibility of duplicate group-by clauses --- the * Check for the possibility of duplicate group-by clauses --- the
* parser should have removed 'em, but no point in sorting * parser should have removed 'em, but no point in sorting
* redundantly. * redundantly.
*/ */
numsortkeys = add_sort_column(resdom->resno, grpcl->sortop, numsortkeys = add_sort_column(tle->resdom->resno, grpcl->sortop,
numsortkeys, sortColIdx, sortOperators); numsortkeys, sortColIdx, sortOperators);
grpno++; grpno++;
} }
Assert(numsortkeys > 0); Assert(numsortkeys > 0);
/* Give Sort node its own copy of the tlist (still necessary?) */ return make_sort(root, lefttree, numsortkeys,
sort_tlist = copyObject(sub_tlist);
return make_sort(root, sort_tlist, lefttree, numsortkeys,
sortColIdx, sortOperators); sortColIdx, sortOperators);
} }
Material * Material *
make_material(List *tlist, Plan *lefttree) make_material(Plan *lefttree)
{ {
Material *node = makeNode(Material); Material *node = makeNode(Material);
Plan *plan = &node->plan; Plan *plan = &node->plan;
/* cost should be inserted by caller */ /* cost should be inserted by caller */
plan->targetlist = tlist; plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL; plan->qual = NIL;
plan->lefttree = lefttree; plan->lefttree = lefttree;
plan->righttree = NULL; plan->righttree = NULL;
@ -2098,7 +2072,7 @@ materialize_finished_plan(Plan *subplan)
Plan *matplan; Plan *matplan;
Path matpath; /* dummy for result of cost_material */ Path matpath; /* dummy for result of cost_material */
matplan = (Plan *) make_material(subplan->targetlist, subplan); matplan = (Plan *) make_material(subplan);
/* Set cost data */ /* Set cost data */
cost_material(&matpath, cost_material(&matpath,
@ -2239,7 +2213,7 @@ make_group(Query *root,
* that should be considered by the Unique filter. * that should be considered by the Unique filter.
*/ */
Unique * Unique *
make_unique(List *tlist, Plan *lefttree, List *distinctList) make_unique(Plan *lefttree, List *distinctList)
{ {
Unique *node = makeNode(Unique); Unique *node = makeNode(Unique);
Plan *plan = &node->plan; Plan *plan = &node->plan;
@ -2263,7 +2237,7 @@ make_unique(List *tlist, Plan *lefttree, List *distinctList)
* this if he has a better idea. * this if he has a better idea.
*/ */
plan->targetlist = tlist; plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL; plan->qual = NIL;
plan->lefttree = lefttree; plan->lefttree = lefttree;
plan->righttree = NULL; plan->righttree = NULL;
@ -2278,7 +2252,7 @@ make_unique(List *tlist, Plan *lefttree, List *distinctList)
foreach(slitem, distinctList) foreach(slitem, distinctList)
{ {
SortClause *sortcl = (SortClause *) lfirst(slitem); SortClause *sortcl = (SortClause *) lfirst(slitem);
TargetEntry *tle = get_sortgroupclause_tle(sortcl, tlist); TargetEntry *tle = get_sortgroupclause_tle(sortcl, plan->targetlist);
uniqColIdx[keyno++] = tle->resdom->resno; uniqColIdx[keyno++] = tle->resdom->resno;
} }
@ -2295,7 +2269,7 @@ make_unique(List *tlist, Plan *lefttree, List *distinctList)
*/ */
SetOp * SetOp *
make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree, make_setop(SetOpCmd cmd, Plan *lefttree,
List *distinctList, AttrNumber flagColIdx) List *distinctList, AttrNumber flagColIdx)
{ {
SetOp *node = makeNode(SetOp); SetOp *node = makeNode(SetOp);
@ -2321,7 +2295,7 @@ make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree,
if (plan->plan_rows < 1) if (plan->plan_rows < 1)
plan->plan_rows = 1; plan->plan_rows = 1;
plan->targetlist = tlist; plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL; plan->qual = NIL;
plan->lefttree = lefttree; plan->lefttree = lefttree;
plan->righttree = NULL; plan->righttree = NULL;
@ -2336,7 +2310,7 @@ make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree,
foreach(slitem, distinctList) foreach(slitem, distinctList)
{ {
SortClause *sortcl = (SortClause *) lfirst(slitem); SortClause *sortcl = (SortClause *) lfirst(slitem);
TargetEntry *tle = get_sortgroupclause_tle(sortcl, tlist); TargetEntry *tle = get_sortgroupclause_tle(sortcl, plan->targetlist);
dupColIdx[keyno++] = tle->resdom->resno; dupColIdx[keyno++] = tle->resdom->resno;
} }
@ -2350,8 +2324,7 @@ make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree,
} }
Limit * Limit *
make_limit(List *tlist, Plan *lefttree, make_limit(Plan *lefttree, Node *limitOffset, Node *limitCount)
Node *limitOffset, Node *limitCount)
{ {
Limit *node = makeNode(Limit); Limit *node = makeNode(Limit);
Plan *plan = &node->plan; Plan *plan = &node->plan;
@ -2401,7 +2374,7 @@ make_limit(List *tlist, Plan *lefttree,
} }
} }
plan->targetlist = tlist; plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL; plan->qual = NIL;
plan->lefttree = lefttree; plan->lefttree = lefttree;
plan->righttree = NULL; plan->righttree = NULL;
@ -2448,3 +2421,27 @@ make_result(List *tlist,
return node; return node;
} }
/*
* is_projection_capable_plan
* Check whether a given Plan node is able to do projection.
*/
bool
is_projection_capable_plan(Plan *plan)
{
/* Most plan types can project, so just list the ones that can't */
switch (nodeTag(plan))
{
case T_Hash:
case T_Material:
case T_Sort:
case T_Unique:
case T_SetOp:
case T_Limit:
case T_Append:
return false;
default:
break;
}
return true;
}

17
src/backend/optimizer/plan/planner.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.164 2004/01/12 22:20:28 tgl Exp $ * $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.165 2004/01/18 00:50:02 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -1103,10 +1103,9 @@ grouping_planner(Query *parse, double tuple_fraction)
/* /*
* If the top-level plan node is one that cannot do expression * If the top-level plan node is one that cannot do expression
* evaluation, we must insert a Result node to project the * evaluation, we must insert a Result node to project the
* desired tlist. Currently, the only plan node we might see * desired tlist.
* here that falls into that category is Append.
*/ */
if (IsA(result_plan, Append)) if (!is_projection_capable_plan(result_plan))
{ {
result_plan = (Plan *) make_result(sub_tlist, NULL, result_plan = (Plan *) make_result(sub_tlist, NULL,
result_plan); result_plan);
@ -1265,9 +1264,8 @@ grouping_planner(Query *parse, double tuple_fraction)
{ {
result_plan = (Plan *) result_plan = (Plan *)
make_sort_from_sortclauses(parse, make_sort_from_sortclauses(parse,
tlist, parse->sortClause,
result_plan, result_plan);
parse->sortClause);
current_pathkeys = sort_pathkeys; current_pathkeys = sort_pathkeys;
} }
} }
@ -1277,8 +1275,7 @@ grouping_planner(Query *parse, double tuple_fraction)
*/ */
if (parse->distinctClause) if (parse->distinctClause)
{ {
result_plan = (Plan *) make_unique(tlist, result_plan, result_plan = (Plan *) make_unique(result_plan, parse->distinctClause);
parse->distinctClause);
/* /*
* If there was grouping or aggregation, leave plan_rows as-is * If there was grouping or aggregation, leave plan_rows as-is
@ -1303,7 +1300,7 @@ grouping_planner(Query *parse, double tuple_fraction)
*/ */
if (parse->limitOffset || parse->limitCount) if (parse->limitOffset || parse->limitCount)
{ {
result_plan = (Plan *) make_limit(tlist, result_plan, result_plan = (Plan *) make_limit(result_plan,
parse->limitOffset, parse->limitOffset,
parse->limitCount); parse->limitCount);
} }

14
src/backend/optimizer/prep/prepunion.c
View File

@ -14,7 +14,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/prep/prepunion.c,v 1.107 2004/01/04 03:51:52 tgl Exp $ * $PostgreSQL: pgsql/src/backend/optimizer/prep/prepunion.c,v 1.108 2004/01/18 00:50:02 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -246,11 +246,9 @@ generate_union_plan(SetOperationStmt *op, Query *parse,
{ {
List *sortList; List *sortList;
tlist = copyObject(tlist);
sortList = addAllTargetsToSortList(NULL, NIL, tlist, false); sortList = addAllTargetsToSortList(NULL, NIL, tlist, false);
plan = (Plan *) make_sort_from_sortclauses(parse, tlist, plan = (Plan *) make_sort_from_sortclauses(parse, sortList, plan);
plan, sortList); plan = (Plan *) make_unique(plan, sortList);
plan = (Plan *) make_unique(tlist, plan, sortList);
} }
return plan; return plan;
} }
@ -300,9 +298,8 @@ generate_nonunion_plan(SetOperationStmt *op, Query *parse,
* Sort the child results, then add a SetOp plan node to generate the * Sort the child results, then add a SetOp plan node to generate the
* correct output. * correct output.
*/ */
tlist = copyObject(tlist);
sortList = addAllTargetsToSortList(NULL, NIL, tlist, false); sortList = addAllTargetsToSortList(NULL, NIL, tlist, false);
plan = (Plan *) make_sort_from_sortclauses(parse, tlist, plan, sortList); plan = (Plan *) make_sort_from_sortclauses(parse, sortList, plan);
switch (op->op) switch (op->op)
{ {
case SETOP_INTERSECT: case SETOP_INTERSECT:
@ -317,8 +314,7 @@ generate_nonunion_plan(SetOperationStmt *op, Query *parse,
cmd = SETOPCMD_INTERSECT; /* keep compiler quiet */ cmd = SETOPCMD_INTERSECT; /* keep compiler quiet */
break; break;
} }
plan = (Plan *) make_setop(cmd, tlist, plan, sortList, plan = (Plan *) make_setop(cmd, plan, sortList, length(op->colTypes) + 1);
length(op->colTypes) + 1);
return plan; return plan;
} }

16
src/include/optimizer/planmain.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $PostgreSQL: pgsql/src/include/optimizer/planmain.h,v 1.76 2003/11/29 22:41:07 pgsql Exp $ * $PostgreSQL: pgsql/src/include/optimizer/planmain.h,v 1.77 2004/01/18 00:50:03 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -30,8 +30,8 @@ extern Plan *create_plan(Query *root, Path *best_path);
extern SubqueryScan *make_subqueryscan(List *qptlist, List *qpqual, extern SubqueryScan *make_subqueryscan(List *qptlist, List *qpqual,
Index scanrelid, Plan *subplan); Index scanrelid, Plan *subplan);
extern Append *make_append(List *appendplans, bool isTarget, List *tlist); extern Append *make_append(List *appendplans, bool isTarget, List *tlist);
extern Sort *make_sort_from_sortclauses(Query *root, List *tlist, extern Sort *make_sort_from_sortclauses(Query *root, List *sortcls,
Plan *lefttree, List *sortcls); Plan *lefttree);
extern Sort *make_sort_from_groupcols(Query *root, List *groupcls, extern Sort *make_sort_from_groupcols(Query *root, List *groupcls,
AttrNumber *grpColIdx, Plan *lefttree); AttrNumber *grpColIdx, Plan *lefttree);
extern Agg *make_agg(Query *root, List *tlist, List *qual, extern Agg *make_agg(Query *root, List *tlist, List *qual,
@ -43,14 +43,14 @@ extern Group *make_group(Query *root, List *tlist,
int numGroupCols, AttrNumber *grpColIdx, int numGroupCols, AttrNumber *grpColIdx,
double numGroups, double numGroups,
Plan *lefttree); Plan *lefttree);
extern Material *make_material(List *tlist, Plan *lefttree); extern Material *make_material(Plan *lefttree);
extern Plan *materialize_finished_plan(Plan *subplan); extern Plan *materialize_finished_plan(Plan *subplan);
extern Unique *make_unique(List *tlist, Plan *lefttree, List *distinctList); extern Unique *make_unique(Plan *lefttree, List *distinctList);
extern Limit *make_limit(List *tlist, Plan *lefttree, extern Limit *make_limit(Plan *lefttree, Node *limitOffset, Node *limitCount);
Node *limitOffset, Node *limitCount); extern SetOp *make_setop(SetOpCmd cmd, Plan *lefttree,
extern SetOp *make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree,
List *distinctList, AttrNumber flagColIdx); List *distinctList, AttrNumber flagColIdx);
extern Result *make_result(List *tlist, Node *resconstantqual, Plan *subplan); extern Result *make_result(List *tlist, Node *resconstantqual, Plan *subplan);
extern bool is_projection_capable_plan(Plan *plan);
/* /*
* prototypes for plan/initsplan.c * prototypes for plan/initsplan.c