Fix inheritance_planner() to delete dummy subplans from its Append plan

list, when some of the child rels have been excluded by constraint
exclusion.  This doesn't save a huge amount of time but it'll save some,
and it makes the EXPLAIN output look saner.  We already did the
equivalent thing in set_append_rel_pathlist(), but not here.

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 42ae15cd4832fdc029dec3ccc5263f943dac43e3..0eeaff064ff4f1f25499436b544a687da7cc4f13 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.206 2006/08/02 01:59:46 joe Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.207 2006/08/05 17:21:52 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -58,6 +58,7 @@ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind);
 static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode);
 static Plan *inheritance_planner(PlannerInfo *root);
 static Plan *grouping_planner(PlannerInfo *root, double tuple_fraction);
+static bool is_dummy_plan(Plan *plan);
 static double preprocess_limit(PlannerInfo *root,
                                 double tuple_fraction,
                                 int64 *offset_est, int64 *count_est);
@@ -553,12 +554,11 @@ inheritance_planner(PlannerInfo *root)
        Query      *parse = root->parse;
        int                     parentRTindex = parse->resultRelation;
        List       *subplans = NIL;
+       List       *rtable = NIL;
        List       *tlist = NIL;
        PlannerInfo subroot;
        ListCell   *l;
 
-       subroot.parse = NULL;           /* catch it if no matches in loop */
-
        parse->resultRelations = NIL;
 
        foreach(l, root->append_rel_list)
@@ -570,10 +570,6 @@ inheritance_planner(PlannerInfo *root)
                if (appinfo->parent_relid != parentRTindex)
                        continue;
 
-               /* Build target-relations list for the executor */
-               parse->resultRelations = lappend_int(parse->resultRelations,
-                                                                                        appinfo->child_relid);
-
                /*
                 * Generate modified query with this rel as target.  We have to be
                 * prepared to translate varnos in in_info_list as well as in the
@@ -592,13 +588,39 @@ inheritance_planner(PlannerInfo *root)
                /* Generate plan */
                subplan = grouping_planner(&subroot, 0.0 /* retrieve all tuples */ );
 
-               subplans = lappend(subplans, subplan);
+               /*
+                * If this child rel was excluded by constraint exclusion, exclude
+                * it from the plan.
+                */
+               if (is_dummy_plan(subplan))
+                       continue;
 
-               /* Save preprocessed tlist from first rel for use in Append */
-               if (tlist == NIL)
+               /* Save rtable and tlist from first rel for use below */
+               if (subplans == NIL)
+               {
+                       rtable = subroot.parse->rtable;
                        tlist = subplan->targetlist;
+               }
+
+               subplans = lappend(subplans, subplan);
+
+               /* Build target-relations list for the executor */
+               parse->resultRelations = lappend_int(parse->resultRelations,
+                                                                                        appinfo->child_relid);
        }
 
+       /* Mark result as unordered (probably unnecessary) */
+       root->query_pathkeys = NIL;
+
+       /*
+        * If we managed to exclude every child rel, return a dummy plan
+        */
+       if (subplans == NIL)
+               return (Plan *) make_result(tlist,
+                                                                       (Node *) list_make1(makeBoolConst(false,
+                                                                                                                                         false)),
+                                                                       NULL);
+
        /*
         * Planning might have modified the rangetable, due to changes of the
         * Query structures inside subquery RTEs.  We have to ensure that this
@@ -610,10 +632,7 @@ inheritance_planner(PlannerInfo *root)
         *
         * XXX should clean this up someday
         */
-       parse->rtable = subroot.parse->rtable;
-
-       /* Mark result as unordered (probably unnecessary) */
-       root->query_pathkeys = NIL;
+       parse->rtable = rtable;
 
        return (Plan *) make_append(subplans, true, tlist);
 }
@@ -1072,6 +1091,35 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
        return result_plan;
 }
 
+/*
+ * Detect whether a plan node is a "dummy" plan created when a relation
+ * is deemed not to need scanning due to constraint exclusion.
+ *
+ * Currently, such dummy plans are Result nodes with constant FALSE
+ * filter quals.
+ */
+static bool
+is_dummy_plan(Plan *plan)
+{
+       if (IsA(plan, Result))
+       {
+               List *rcqual = (List *) ((Result *) plan)->resconstantqual;
+
+               if (list_length(rcqual) == 1)
+               {
+                       Const *constqual = (Const *) linitial(rcqual);
+
+                       if (constqual && IsA(constqual, Const))
+                       {
+                               if (!constqual->constisnull &&
+                                       !DatumGetBool(constqual->constvalue))
+                                       return true;
+                       }
+               }
+       }
+       return false;
+}
+
 /*
  * preprocess_limit - do pre-estimation for LIMIT and/or OFFSET clauses
  *