Make EXPLAIN results for Append, Group, Agg, Unique nodes more plausible.

Group and Unique use an arbitrary assumption that there will be about
10% as many groups as input tuples --- perhaps someday we can refine this.

diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 70a73821641bebd691293fa9fd00e220b3c2b168..69c0a3f65be8bd0e454c253443a8b8daac54e4e2 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.82 2000/01/27 18:11:30 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.83 2000/02/03 06:12:18 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -743,9 +743,9 @@ create_hashjoin_node(HashPath *best_path,
  *     * Var nodes representing index keys must have varattno equal to the
  *       index's attribute number, not the attribute number in the original rel.
  *     * indxpath.c may have selected an index that is binary-compatible with
- *       the actual expression operator, but not the same; we must replace the
- *       expression's operator with the binary-compatible equivalent operator
- *       that the index will recognize.
+ *       the actual expression operator, but not exactly the same datatype.
+ *       We must replace the expression's operator with the binary-compatible
+ *       equivalent operator that the index will recognize.
  *     * If the index key is on the right, commute the clause to put it on the
  *       left.  (Someday the executor might not need this, but for now it does.)
  *
@@ -1054,6 +1054,7 @@ copy_path_costsize(Plan *dest, Path *src)
  * Copy cost and size info from a lower plan node to an inserted node.
  * This is not critical, since the decisions have already been made,
  * but it helps produce more reasonable-looking EXPLAIN output.
+ * (Some callers alter the info after copying it.)
  */
 static void
 copy_plan_costsize(Plan *dest, Plan *src)
@@ -1178,12 +1179,7 @@ make_nestloop(List *qptlist,
        NestLoop   *node = makeNode(NestLoop);
        Plan       *plan = &node->join;
 
-       /*
-        * this cost estimate is entirely bogus... hopefully it will be
-        * overwritten by caller.
-        */
-       plan->cost = (lefttree ? lefttree->cost : 0) +
-               (righttree ? righttree->cost : 0);
+       /* cost should be inserted by caller */
        plan->state = (EState *) NULL;
        plan->targetlist = qptlist;
        plan->qual = qpqual;
@@ -1204,12 +1200,7 @@ make_hashjoin(List *tlist,
        HashJoin   *node = makeNode(HashJoin);
        Plan       *plan = &node->join;
 
-       /*
-        * this cost estimate is entirely bogus... hopefully it will be
-        * overwritten by caller.
-        */
-       plan->cost = (lefttree ? lefttree->cost : 0) +
-               (righttree ? righttree->cost : 0);
+       /* cost should be inserted by caller */
        plan->state = (EState *) NULL;
        plan->targetlist = tlist;
        plan->qual = qpqual;
@@ -1248,12 +1239,7 @@ make_mergejoin(List *tlist,
        MergeJoin  *node = makeNode(MergeJoin);
        Plan       *plan = &node->join;
 
-       /*
-        * this cost estimate is entirely bogus... hopefully it will be
-        * overwritten by caller.
-        */
-       plan->cost = (lefttree ? lefttree->cost : 0) +
-               (righttree ? righttree->cost : 0);
+       /* cost should be inserted by caller */
        plan->state = (EState *) NULL;
        plan->targetlist = tlist;
        plan->qual = qpqual;
@@ -1293,6 +1279,7 @@ make_material(List *tlist,
        Plan       *plan = &node->plan;
 
        copy_plan_costsize(plan, lefttree);
+       /* XXX shouldn't we charge some additional cost for materialization? */
        plan->state = (EState *) NULL;
        plan->targetlist = tlist;
        plan->qual = NIL;
@@ -1310,6 +1297,20 @@ make_agg(List *tlist, Plan *lefttree)
        Agg                *node = makeNode(Agg);
 
        copy_plan_costsize(&node->plan, lefttree);
+       /*
+        * The tuple width from the input node is OK, as is the cost (we are
+        * ignoring the cost of computing the aggregate; is there any value
+        * in accounting for it?).  But the tuple count is bogus.  We will
+        * produce a single tuple if the input is not a Group, and a tuple
+        * per group otherwise.  For now, estimate the number of groups as
+        * 10% of the number of tuples --- bogus, but how to do better?
+        * (Note we assume the input Group node is in "tuplePerGroup" mode,
+        * so it didn't reduce its row count already.)
+        */
+       if (IsA(lefttree, Group))
+               node->plan.plan_rows *= 0.1;
+       else
+               node->plan.plan_rows = 1;
        node->plan.state = (EState *) NULL;
        node->plan.qual = NULL;
        node->plan.targetlist = tlist;
@@ -1329,6 +1330,15 @@ make_group(List *tlist,
        Group      *node = makeNode(Group);
 
        copy_plan_costsize(&node->plan, lefttree);
+       /*
+        * If tuplePerGroup (which is named exactly backwards) is true,
+        * we will return all the input tuples, so the input node's row count
+        * is OK.  Otherwise, we'll return only one tuple from each group.
+        * For now, estimate the number of groups as 10% of the number of
+        * tuples --- bogus, but how to do better?
+        */
+       if (! tuplePerGroup)
+               node->plan.plan_rows *= 0.1;
        node->plan.state = (EState *) NULL;
        node->plan.qual = NULL;
        node->plan.targetlist = tlist;
@@ -1357,6 +1367,11 @@ make_unique(List *tlist, Plan *lefttree, List *distinctList)
        List       *slitem;
 
        copy_plan_costsize(plan, lefttree);
+       /*
+        * As for Group, we make the unsupported assumption that there will be
+        * 10% as many tuples out as in.
+        */
+       plan->plan_rows *= 0.1;
        plan->state = (EState *) NULL;
        plan->targetlist = tlist;
        plan->qual = NIL;

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 4323b652e8d8a8fd2844c902ba4d1d0a2021b8a0..95005f166f164187d44e3c547b8ae70d2b664971 100644 (file)
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.42 2000/01/27 18:11:32 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/optimizer/prep/prepunion.c,v 1.43 2000/02/03 06:12:19 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -218,11 +218,11 @@ plan_union_queries(Query *parse)
        parse->havingQual = NULL;
        parse->hasAggs = false;
 
-       return (make_append(union_plans,
-                                               union_rts,
-                                               0,
-                                               NULL,
-                                               parse->targetList));
+       return make_append(union_plans,
+                                          union_rts,
+                                          0,
+                                          NULL,
+                                          parse->targetList);
 }
 
 
@@ -272,11 +272,11 @@ plan_inherit_queries(Query *parse, List *tlist, Index rt_index)
        union_plans = plan_inherit_query(union_relids, rt_index, rt_entry,
                                                                         parse, tlist, &inheritrtable);
 
-       return (make_append(union_plans,
-                                               NULL,
-                                               rt_index,
-                                               inheritrtable,
-                                               ((Plan *) lfirst(union_plans))->targetlist));
+       return make_append(union_plans,
+                                          NULL,
+                                          rt_index,
+                                          inheritrtable,
+                                          ((Plan *) lfirst(union_plans))->targetlist);
 }
 
 /*
@@ -551,9 +551,18 @@ make_append(List *appendplans,
        node->unionrtables = unionrtables;
        node->inheritrelid = rt_index;
        node->inheritrtable = inheritrtable;
-       node->plan.cost = 0.0;
+       node->plan.cost = 0;
+       node->plan.plan_rows = 0;
+       node->plan.plan_width = 0;
        foreach(subnode, appendplans)
-               node->plan.cost += ((Plan *) lfirst(subnode))->cost;
+       {
+               Plan   *subplan = (Plan *) lfirst(subnode);
+
+               node->plan.cost += subplan->cost;
+               node->plan.plan_rows += subplan->plan_rows;
+               if (node->plan.plan_width < subplan->plan_width)
+                       node->plan.plan_width = subplan->plan_width;
+       }
        node->plan.state = (EState *) NULL;
        node->plan.targetlist = tlist;
        node->plan.qual = NIL;