aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/backend/optimizer/plan/createplan.c125
-rw-r--r--src/backend/optimizer/plan/planner.c17
-rw-r--r--src/backend/optimizer/prep/prepunion.c14
-rw-r--r--src/include/optimizer/planmain.h16
4 files changed, 81 insertions, 91 deletions
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 0f83f390715..ffb34e4be5b 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -10,7 +10,7 @@
*
*
* 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,
Plan *lefttree, Plan *righttree,
JoinType jointype);
-static Hash *make_hash(List *tlist, Plan *lefttree);
+static Hash *make_hash(Plan *lefttree);
static MergeJoin *make_mergejoin(List *tlist,
List *joinclauses, List *otherclauses,
List *mergeclauses,
Plan *lefttree, Plan *righttree,
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);
static Sort *make_sort_from_pathkeys(Query *root, Plan *lefttree,
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 */
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);
@@ -518,7 +518,6 @@ create_unique_plan(Query *root, UniquePath *best_path)
List *newtlist;
int nextresno;
bool newitems;
- List *my_tlist;
List *l;
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
* 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);
else
subplan->targetlist = newtlist;
@@ -610,9 +606,6 @@ create_unique_plan(Query *root, UniquePath *best_path)
if (best_path->umethod == UNIQUE_PATH_NOOP)
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)
{
long numGroups;
@@ -620,7 +613,7 @@ create_unique_plan(Query *root, UniquePath *best_path)
numGroups = (long) Min(best_path->rows, (double) LONG_MAX);
plan = (Plan *) make_agg(root,
- my_tlist,
+ copyObject(subplan->targetlist),
NIL,
AGG_HASHED,
numGroupCols,
@@ -637,15 +630,15 @@ create_unique_plan(Query *root, UniquePath *best_path)
{
TargetEntry *tle;
- tle = get_tle_by_resno(my_tlist, groupColIdx[groupColPos]);
+ tle = get_tle_by_resno(subplan->targetlist,
+ groupColIdx[groupColPos]);
Assert(tle != NULL);
sortList = addTargetToSortList(NULL, tle,
- sortList, my_tlist,
+ sortList, subplan->targetlist,
SORTBY_ASC, NIL, false);
}
- plan = (Plan *) make_sort_from_sortclauses(root, my_tlist,
- subplan, sortList);
- plan = (Plan *) make_unique(my_tlist, plan, sortList);
+ plan = (Plan *) make_sort_from_sortclauses(root, sortList, subplan);
+ plan = (Plan *) make_unique(plan, sortList);
}
/* 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.
*/
- hash_plan = make_hash(inner_plan->targetlist,
- inner_plan);
+ hash_plan = make_hash(inner_plan);
join_plan = make_hashjoin(tlist,
joinclauses,
otherclauses,
@@ -1735,7 +1727,7 @@ make_hashjoin(List *tlist,
}
static Hash *
-make_hash(List *tlist, Plan *lefttree)
+make_hash(Plan *lefttree)
{
Hash *node = makeNode(Hash);
Plan *plan = &node->plan;
@@ -1747,7 +1739,7 @@ make_hash(List *tlist, Plan *lefttree)
* input plan; this only affects EXPLAIN display not decisions.
*/
plan->startup_cost = plan->total_cost;
- plan->targetlist = tlist;
+ plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL;
plan->lefttree = lefttree;
plan->righttree = NULL;
@@ -1785,7 +1777,7 @@ make_mergejoin(List *tlist,
* Caller must have built the sortColIdx and sortOperators arrays already.
*/
static Sort *
-make_sort(Query *root, List *tlist, Plan *lefttree, int numCols,
+make_sort(Query *root, Plan *lefttree, int numCols,
AttrNumber *sortColIdx, Oid *sortOperators)
{
Sort *node = makeNode(Sort);
@@ -1799,7 +1791,7 @@ make_sort(Query *root, List *tlist, Plan *lefttree, int numCols,
lefttree->plan_width);
plan->startup_cost = sort_path.startup_cost;
plan->total_cost = sort_path.total_cost;
- plan->targetlist = tlist;
+ plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL;
plan->lefttree = lefttree;
plan->righttree = NULL;
@@ -1862,7 +1854,6 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
Relids relids, List *pathkeys)
{
List *tlist = lefttree->targetlist;
- List *sort_tlist;
List *i;
int numsortkeys;
AttrNumber *sortColIdx;
@@ -1916,11 +1907,8 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
/*
* 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);
lefttree = (Plan *) make_result(tlist, NULL, lefttree);
@@ -1952,10 +1940,7 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
Assert(numsortkeys > 0);
- /* Give Sort node its own copy of the tlist (still necessary?) */
- sort_tlist = copyObject(tlist);
-
- return make_sort(root, sort_tlist, lefttree, numsortkeys,
+ return make_sort(root, lefttree, numsortkeys,
sortColIdx, sortOperators);
}
@@ -1963,15 +1948,13 @@ make_sort_from_pathkeys(Query *root, Plan *lefttree,
* make_sort_from_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
+ * 'lefttree' is the node which yields input tuples
*/
Sort *
-make_sort_from_sortclauses(Query *root, List *tlist,
- Plan *lefttree, List *sortcls)
+make_sort_from_sortclauses(Query *root, List *sortcls, Plan *lefttree)
{
- List *sort_tlist;
+ List *sub_tlist = lefttree->targetlist;
List *i;
int numsortkeys;
AttrNumber *sortColIdx;
@@ -1987,24 +1970,20 @@ make_sort_from_sortclauses(Query *root, List *tlist,
foreach(i, sortcls)
{
SortClause *sortcl = (SortClause *) lfirst(i);
- TargetEntry *tle = get_sortgroupclause_tle(sortcl, tlist);
- Resdom *resdom = tle->resdom;
+ TargetEntry *tle = get_sortgroupclause_tle(sortcl, sub_tlist);
/*
* Check for the possibility of duplicate order-by clauses --- the
* parser should have removed 'em, but no point in sorting
* redundantly.
*/
- numsortkeys = add_sort_column(resdom->resno, sortcl->sortop,
+ numsortkeys = add_sort_column(tle->resdom->resno, sortcl->sortop,
numsortkeys, sortColIdx, sortOperators);
}
Assert(numsortkeys > 0);
- /* Give Sort node its own copy of the tlist (still necessary?) */
- sort_tlist = copyObject(tlist);
-
- return make_sort(root, sort_tlist, lefttree, numsortkeys,
+ return make_sort(root, lefttree, numsortkeys,
sortColIdx, sortOperators);
}
@@ -2028,7 +2007,6 @@ make_sort_from_groupcols(Query *root,
Plan *lefttree)
{
List *sub_tlist = lefttree->targetlist;
- List *sort_tlist;
int grpno = 0;
List *i;
int numsortkeys;
@@ -2046,35 +2024,31 @@ make_sort_from_groupcols(Query *root,
{
GroupClause *grpcl = (GroupClause *) lfirst(i);
TargetEntry *tle = get_tle_by_resno(sub_tlist, grpColIdx[grpno]);
- Resdom *resdom = tle->resdom;
/*
* Check for the possibility of duplicate group-by clauses --- the
* parser should have removed 'em, but no point in sorting
* redundantly.
*/
- numsortkeys = add_sort_column(resdom->resno, grpcl->sortop,
+ numsortkeys = add_sort_column(tle->resdom->resno, grpcl->sortop,
numsortkeys, sortColIdx, sortOperators);
grpno++;
}
Assert(numsortkeys > 0);
- /* Give Sort node its own copy of the tlist (still necessary?) */
- sort_tlist = copyObject(sub_tlist);
-
- return make_sort(root, sort_tlist, lefttree, numsortkeys,
+ return make_sort(root, lefttree, numsortkeys,
sortColIdx, sortOperators);
}
Material *
-make_material(List *tlist, Plan *lefttree)
+make_material(Plan *lefttree)
{
Material *node = makeNode(Material);
Plan *plan = &node->plan;
/* cost should be inserted by caller */
- plan->targetlist = tlist;
+ plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL;
plan->lefttree = lefttree;
plan->righttree = NULL;
@@ -2098,7 +2072,7 @@ materialize_finished_plan(Plan *subplan)
Plan *matplan;
Path matpath; /* dummy for result of cost_material */
- matplan = (Plan *) make_material(subplan->targetlist, subplan);
+ matplan = (Plan *) make_material(subplan);
/* Set cost data */
cost_material(&matpath,
@@ -2239,7 +2213,7 @@ make_group(Query *root,
* that should be considered by the Unique filter.
*/
Unique *
-make_unique(List *tlist, Plan *lefttree, List *distinctList)
+make_unique(Plan *lefttree, List *distinctList)
{
Unique *node = makeNode(Unique);
Plan *plan = &node->plan;
@@ -2263,7 +2237,7 @@ make_unique(List *tlist, Plan *lefttree, List *distinctList)
* this if he has a better idea.
*/
- plan->targetlist = tlist;
+ plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL;
plan->lefttree = lefttree;
plan->righttree = NULL;
@@ -2278,7 +2252,7 @@ make_unique(List *tlist, Plan *lefttree, List *distinctList)
foreach(slitem, distinctList)
{
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;
}
@@ -2295,7 +2269,7 @@ make_unique(List *tlist, Plan *lefttree, List *distinctList)
*/
SetOp *
-make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree,
+make_setop(SetOpCmd cmd, Plan *lefttree,
List *distinctList, AttrNumber flagColIdx)
{
SetOp *node = makeNode(SetOp);
@@ -2321,7 +2295,7 @@ make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree,
if (plan->plan_rows < 1)
plan->plan_rows = 1;
- plan->targetlist = tlist;
+ plan->targetlist = copyObject(lefttree->targetlist);
plan->qual = NIL;
plan->lefttree = lefttree;
plan->righttree = NULL;
@@ -2336,7 +2310,7 @@ make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree,
foreach(slitem, distinctList)
{
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;
}
@@ -2350,8 +2324,7 @@ make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree,
}
Limit *
-make_limit(List *tlist, Plan *lefttree,
- Node *limitOffset, Node *limitCount)
+make_limit(Plan *lefttree, Node *limitOffset, Node *limitCount)
{
Limit *node = makeNode(Limit);
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->lefttree = lefttree;
plan->righttree = NULL;
@@ -2448,3 +2421,27 @@ make_result(List *tlist,
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;
+}
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 7af46244bbb..00ba58ec8bc 100644
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -8,7 +8,7 @@
*
*
* 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
* evaluation, we must insert a Result node to project the
- * desired tlist. Currently, the only plan node we might see
- * here that falls into that category is Append.
+ * desired tlist.
*/
- if (IsA(result_plan, Append))
+ if (!is_projection_capable_plan(result_plan))
{
result_plan = (Plan *) make_result(sub_tlist, NULL,
result_plan);
@@ -1265,9 +1264,8 @@ grouping_planner(Query *parse, double tuple_fraction)
{
result_plan = (Plan *)
make_sort_from_sortclauses(parse,
- tlist,
- result_plan,
- parse->sortClause);
+ parse->sortClause,
+ result_plan);
current_pathkeys = sort_pathkeys;
}
}
@@ -1277,8 +1275,7 @@ grouping_planner(Query *parse, double tuple_fraction)
*/
if (parse->distinctClause)
{
- result_plan = (Plan *) make_unique(tlist, result_plan,
- parse->distinctClause);
+ result_plan = (Plan *) make_unique(result_plan, parse->distinctClause);
/*
* 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)
{
- result_plan = (Plan *) make_limit(tlist, result_plan,
+ result_plan = (Plan *) make_limit(result_plan,
parse->limitOffset,
parse->limitCount);
}
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index d52f2a73417..9424fc71482 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -14,7 +14,7 @@
*
*
* 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;
- tlist = copyObject(tlist);
sortList = addAllTargetsToSortList(NULL, NIL, tlist, false);
- plan = (Plan *) make_sort_from_sortclauses(parse, tlist,
- plan, sortList);
- plan = (Plan *) make_unique(tlist, plan, sortList);
+ plan = (Plan *) make_sort_from_sortclauses(parse, sortList, plan);
+ plan = (Plan *) make_unique(plan, sortList);
}
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
* correct output.
*/
- tlist = copyObject(tlist);
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)
{
case SETOP_INTERSECT:
@@ -317,8 +314,7 @@ generate_nonunion_plan(SetOperationStmt *op, Query *parse,
cmd = SETOPCMD_INTERSECT; /* keep compiler quiet */
break;
}
- plan = (Plan *) make_setop(cmd, tlist, plan, sortList,
- length(op->colTypes) + 1);
+ plan = (Plan *) make_setop(cmd, plan, sortList, length(op->colTypes) + 1);
return plan;
}
diff --git a/src/include/optimizer/planmain.h b/src/include/optimizer/planmain.h
index 9f1ed28aa18..f9368d525c4 100644
--- a/src/include/optimizer/planmain.h
+++ b/src/include/optimizer/planmain.h
@@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* 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,
Index scanrelid, Plan *subplan);
extern Append *make_append(List *appendplans, bool isTarget, List *tlist);
-extern Sort *make_sort_from_sortclauses(Query *root, List *tlist,
- Plan *lefttree, List *sortcls);
+extern Sort *make_sort_from_sortclauses(Query *root, List *sortcls,
+ Plan *lefttree);
extern Sort *make_sort_from_groupcols(Query *root, List *groupcls,
AttrNumber *grpColIdx, Plan *lefttree);
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,
double numGroups,
Plan *lefttree);
-extern Material *make_material(List *tlist, Plan *lefttree);
+extern Material *make_material(Plan *lefttree);
extern Plan *materialize_finished_plan(Plan *subplan);
-extern Unique *make_unique(List *tlist, Plan *lefttree, List *distinctList);
-extern Limit *make_limit(List *tlist, Plan *lefttree,
- Node *limitOffset, Node *limitCount);
-extern SetOp *make_setop(SetOpCmd cmd, List *tlist, Plan *lefttree,
+extern Unique *make_unique(Plan *lefttree, List *distinctList);
+extern Limit *make_limit(Plan *lefttree, Node *limitOffset, Node *limitCount);
+extern SetOp *make_setop(SetOpCmd cmd, Plan *lefttree,
List *distinctList, AttrNumber flagColIdx);
extern Result *make_result(List *tlist, Node *resconstantqual, Plan *subplan);
+extern bool is_projection_capable_plan(Plan *plan);
/*
* prototypes for plan/initsplan.c
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-02 00:19:23 +0000