Cause planner to account for evaluation costs in targetlists and

HAVING quals.  Normally this is an insignificant effect --- but it
will not be insignificant when these clauses contain sub-selects.
The added costs cannot affect the planning of the query containing
them, but they might have an impact when the query is a sub-query
of a larger one.

src/backend/optimizer/plan/createplan.c

@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.128 2002/12/12 15:49:32 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.129 2003/01/13 00:29:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1366,6 +1366,7 @@ make_subqueryscan(List *qptlist,
 	SubqueryScan *node = makeNode(SubqueryScan);
 	Plan	   *plan = &node->scan.plan;
 
+	/* cost is figured here for the convenience of prepunion.c */
 	copy_plan_costsize(plan, subplan);
 	plan->targetlist = qptlist;
 	plan->qual = qpqual;
@@ -1488,7 +1489,7 @@ make_hash(List *tlist, List *hashkeys, Plan *lefttree)
 	 */
 	plan->startup_cost = plan->total_cost;
 	plan->targetlist = tlist;
-	plan->qual = NULL;
+	plan->qual = NIL;
 	plan->lefttree = lefttree;
 	plan->righttree = NULL;
 	node->hashkeys = hashkeys;
@@ -1646,6 +1647,7 @@ make_agg(Query *root, List *tlist, List *qual,
 	Agg		   *node = makeNode(Agg);
 	Plan	   *plan = &node->plan;
 	Path		agg_path;		/* dummy for result of cost_agg */
+	QualCost	qual_cost;
 
 	node->aggstrategy = aggstrategy;
 	node->numCols = numGroupCols;
@@ -1671,6 +1673,27 @@ make_agg(Query *root, List *tlist, List *qual,
 	else
 		plan->plan_rows = numGroups;
 
+	/*
+	 * We also need to account for the cost of evaluation of the qual
+	 * (ie, the HAVING clause) and the tlist.  Note that cost_qual_eval
+	 * doesn't charge anything for Aggref nodes; this is okay since
+	 * they are really comparable to Vars.
+	 *
+	 * See notes in grouping_planner about why this routine and make_group
+	 * are the only ones in this file that worry about tlist eval cost.
+	 */
+	if (qual)
+	{
+		cost_qual_eval(&qual_cost, qual);
+		plan->startup_cost += qual_cost.startup;
+		plan->total_cost += qual_cost.startup;
+		plan->total_cost += qual_cost.per_tuple * plan->plan_rows;
+	}
+	cost_qual_eval(&qual_cost, tlist);
+	plan->startup_cost += qual_cost.startup;
+	plan->total_cost += qual_cost.startup;
+	plan->total_cost += qual_cost.per_tuple * plan->plan_rows;
+
 	plan->qual = qual;
 	plan->targetlist = tlist;
 	plan->lefttree = lefttree;
@@ -1690,6 +1713,7 @@ make_group(Query *root,
 	Group	   *node = makeNode(Group);
 	Plan	   *plan = &node->plan;
 	Path		group_path;		/* dummy for result of cost_group */
+	QualCost	qual_cost;
 
 	node->numCols = numGroupCols;
 	node->grpColIdx = grpColIdx;
@@ -1706,7 +1730,23 @@ make_group(Query *root,
 	/* One output tuple per estimated result group */
 	plan->plan_rows = numGroups;
 
-	plan->qual = NULL;
+	/*
+	 * We also need to account for the cost of evaluation of the tlist.
+	 *
+	 * XXX this double-counts the cost of evaluation of any expressions
+	 * used for grouping, since in reality those will have been evaluated
+	 * at a lower plan level and will only be copied by the Group node.
+	 * Worth fixing?
+	 *
+	 * See notes in grouping_planner about why this routine and make_agg
+	 * are the only ones in this file that worry about tlist eval cost.
+	 */
+	cost_qual_eval(&qual_cost, tlist);
+	plan->startup_cost += qual_cost.startup;
+	plan->total_cost += qual_cost.startup;
+	plan->total_cost += qual_cost.per_tuple * plan->plan_rows;
+
+	plan->qual = NIL;
 	plan->targetlist = tlist;
 	plan->lefttree = lefttree;
 	plan->righttree = (Plan *) NULL;
@@ -1718,7 +1758,6 @@ make_group(Query *root,
  * distinctList is a list of SortClauses, identifying the targetlist items
  * that should be considered by the Unique filter.
  */
-
 Unique *
 make_unique(List *tlist, Plan *lefttree, List *distinctList)
 {
@@ -1911,6 +1950,16 @@ make_result(List *tlist,
 		plan->plan_width = 0;	/* XXX try to be smarter? */
 	}
 
+	if (resconstantqual)
+	{
+		QualCost	qual_cost;
+
+		cost_qual_eval(&qual_cost, (List *) resconstantqual);
+		/* resconstantqual is evaluated once at startup */
+		plan->startup_cost += qual_cost.startup + qual_cost.per_tuple;
+		plan->total_cost += qual_cost.startup + qual_cost.per_tuple;
+	}
+
 	plan->targetlist = tlist;
 	plan->qual = NIL;
 	plan->lefttree = subplan;

src/backend/optimizer/plan/planner.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.136 2002/12/19 23:25:01 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.137 2003/01/13 00:29:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -966,6 +966,7 @@ grouping_planner(Query *parse, double tuple_fraction)
 		List	   *sub_tlist;
 		List	   *group_pathkeys;
 		AttrNumber *groupColIdx = NULL;
+		QualCost	tlist_cost;
 		double		sub_tuple_fraction;
 		Path	   *cheapest_path;
 		Path	   *sorted_path;
@@ -1452,6 +1453,27 @@ grouping_planner(Query *parse, double tuple_fraction)
 			 */
 			result_plan->targetlist = sub_tlist;
 		}
+		/*
+		 * Also, account for the cost of evaluation of the sub_tlist.
+		 *
+		 * Up to now, we have only been dealing with "flat" tlists, containing
+		 * just Vars.  So their evaluation cost is zero according to the
+		 * model used by cost_qual_eval() (or if you prefer, the cost is
+		 * factored into cpu_tuple_cost).  Thus we can avoid accounting for
+		 * tlist cost throughout query_planner() and subroutines.
+		 * But now we've inserted a tlist that might contain actual operators,
+		 * sub-selects, etc --- so we'd better account for its cost.
+		 *
+		 * Below this point, any tlist eval cost for added-on nodes should
+		 * be accounted for as we create those nodes.  Presently, of the
+		 * node types we can add on, only Agg and Group project new tlists
+		 * (the rest just copy their input tuples) --- so make_agg() and
+		 * make_group() are responsible for computing the added cost.
+		 */
+		cost_qual_eval(&tlist_cost, sub_tlist);
+		result_plan->startup_cost += tlist_cost.startup;
+		result_plan->total_cost += tlist_cost.startup +
+			tlist_cost.per_tuple * result_plan->plan_rows;
 
 		/*
 		 * Insert AGG or GROUP node if needed, plus an explicit sort step

src/backend/optimizer/plan/subselect.c

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.64 2003/01/12 04:03:34 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/plan/subselect.c,v 1.65 2003/01/13 00:29:26 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -378,6 +378,8 @@ make_subplan(SubLink *slink, List *lefthand)
 							  plan->plan_width);
 				matplan->startup_cost = matpath.startup_cost;
 				matplan->total_cost = matpath.total_cost;
+				matplan->plan_rows = plan->plan_rows;
+				matplan->plan_width = plan->plan_width;
 				/* parameter kluge --- see comments above */
 				matplan->extParam = listCopy(plan->extParam);
 				matplan->locParam = listCopy(plan->locParam);