Make cost estimates for SubqueryScan more realistic: charge cpu_tuple_cost

for each row processed, and don't forget the evaluation cost of any
restriction clauses attached to the node.  Per discussion with Greg Stark.

diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index 34a3aaf1c949b5a17303ee62bd208f3dececc14a..3011f687c593f8130d469fea8115fa914593f1c1 100644 (file)
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -49,7 +49,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.109 2003/06/29 23:05:04 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.110 2003/07/14 22:35:54 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -415,6 +415,38 @@ cost_tidscan(Path *path, Query *root,
        path->total_cost = startup_cost + run_cost;
 }
 
+/*
+ * cost_subqueryscan
+ *       Determines and returns the cost of scanning a subquery RTE.
+ */
+void
+cost_subqueryscan(Path *path, RelOptInfo *baserel)
+{
+       Cost            startup_cost;
+       Cost            run_cost;
+       Cost            cpu_per_tuple;
+
+       /* Should only be applied to base relations that are subqueries */
+       Assert(baserel->relid > 0);
+       Assert(baserel->rtekind == RTE_SUBQUERY);
+
+       /*
+        * Cost of path is cost of evaluating the subplan, plus cost of
+        * evaluating any restriction clauses that will be attached to the
+        * SubqueryScan node, plus cpu_tuple_cost to account for selection
+        * and projection overhead.
+        */
+       path->startup_cost = baserel->subplan->startup_cost;
+       path->total_cost = baserel->subplan->total_cost;
+
+       startup_cost = baserel->baserestrictcost.startup;
+       cpu_per_tuple = cpu_tuple_cost + baserel->baserestrictcost.per_tuple;
+       run_cost = cpu_per_tuple * baserel->tuples;
+
+       path->startup_cost += startup_cost;
+       path->total_cost += startup_cost + run_cost;
+}
+
 /*
  * cost_functionscan
  *       Determines and returns the cost of scanning a function RTE.

diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 1cdc3628b20ceb718b4e380e66232c12e77b1076..79855b00c0f97594b78cd91e540d5021b8ae5151 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.147 2003/06/29 23:05:04 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.148 2003/07/14 22:35:54 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -811,6 +811,8 @@ create_subqueryscan_plan(Path *best_path, List *tlist, List *scan_clauses)
                                                                  scan_relid,
                                                                  best_path->parent->subplan);
 
+       copy_path_costsize(&scan_plan->scan.plan, best_path);
+
        return scan_plan;
 }
 
@@ -1503,8 +1505,14 @@ make_subqueryscan(List *qptlist,
        SubqueryScan *node = makeNode(SubqueryScan);
        Plan       *plan = &node->scan.plan;
 
-       /* cost is figured here for the convenience of prepunion.c */
+       /*
+        * Cost is figured here for the convenience of prepunion.c.  Note this
+        * is only correct for the case where qpqual is empty; otherwise caller
+        * should overwrite cost with a better estimate.
+        */
        copy_plan_costsize(plan, subplan);
+       plan->total_cost += cpu_tuple_cost * subplan->plan_rows;
+
        plan->targetlist = qptlist;
        plan->qual = qpqual;
        plan->lefttree = NULL;
@@ -1540,7 +1548,11 @@ make_append(List *appendplans, bool isTarget, List *tlist)
        Plan       *plan = &node->plan;
        List       *subnode;
 
-       /* compute costs from subplan costs */
+       /*
+        * Compute cost as sum of subplan costs.  We charge nothing extra for
+        * the Append itself, which perhaps is too optimistic, but since it
+        * doesn't do any selection or projection, it is a pretty cheap node.
+        */
        plan->startup_cost = 0;
        plan->total_cost = 0;
        plan->plan_rows = 0;
@@ -1556,6 +1568,7 @@ make_append(List *appendplans, bool isTarget, List *tlist)
                if (plan->plan_width < subplan->plan_width)
                        plan->plan_width = subplan->plan_width;
        }
+
        plan->targetlist = tlist;
        plan->qual = NIL;
        plan->lefttree = NULL;

diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index 9e919079ccf9c2d6d1f18ee34c6bb2a70259826e..19198bf2494c88c2495b1d2999e6f22b187bc296 100644 (file)
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.91 2003/06/29 23:05:04 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.92 2003/07/14 22:35:54 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -686,9 +686,7 @@ create_subqueryscan_path(RelOptInfo *rel, List *pathkeys)
        pathnode->parent = rel;
        pathnode->pathkeys = pathkeys;
 
-       /* just copy the subplan's cost estimates */
-       pathnode->startup_cost = rel->subplan->startup_cost;
-       pathnode->total_cost = rel->subplan->total_cost;
+       cost_subqueryscan(pathnode, rel);
 
        return pathnode;
 }

diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h
index 45c83191a2691ff2e34b74ccb8d702cbb6ca8399..ad2122f46e70f9d21f2543d77c42e34ce8daae64 100644 (file)
--- a/src/include/optimizer/cost.h
+++ b/src/include/optimizer/cost.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: cost.h,v 1.53 2003/06/11 15:01:15 momjian Exp $
+ * $Id: cost.h,v 1.54 2003/07/14 22:35:54 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -56,6 +56,7 @@ extern void cost_index(Path *path, Query *root,
                   List *indexQuals, bool is_injoin);
 extern void cost_tidscan(Path *path, Query *root,
                         RelOptInfo *baserel, List *tideval);
+extern void cost_subqueryscan(Path *path, RelOptInfo *baserel);
 extern void cost_functionscan(Path *path, Query *root,
                                  RelOptInfo *baserel);
 extern void cost_sort(Path *path, Query *root,