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.

diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index a67e23f..3d9ee6e 100644 (file)
--- a/src/backend/optimizer/plan/createplan.c
+++ b/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;

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index e886b88..3b89810 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/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

diff --git a/src/backend/optimizer/plan/subselect.c b/src/backend/optimizer/plan/subselect.c
index 2feaff1..42da081 100644 (file)
--- a/src/backend/optimizer/plan/subselect.c
+++ b/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);