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.

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);
 	}

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;
 }
 

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