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.

diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 0f83f390715aeed5d7b0123c9e06f79f5628f685..ffb34e4be5ba3a92b8f500a34cbf445d181b25f6 100644 (file)
--- 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 7af46244bbb629ea5e8c4251217dd89ad7a008f3..00ba58ec8bca8233ecc17e51496167f8153fb19d 100644 (file)
--- 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 d52f2a73417ab92fad3324a59dd6c47e77d14602..9424fc7148282623881835c51069522df418113f 100644 (file)
--- 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 9f1ed28aa188b0f8134a3882d333a09358b8c83d..f9368d525c44ab8398a6949f61753c2d7f477b0b 100644 (file)
--- 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