Recognize self-contradictory restriction clauses for non-table relations.

The constraint exclusion feature checks for contradictions among scan
restriction clauses, as well as contradictions between those clauses and a
table's CHECK constraints.  The first aspect of this testing can be useful
for non-table relations (such as subqueries or functions-in-FROM), but the
feature was coded with only the CHECK case in mind so we were applying it
only to plain-table RTEs.  Move the relation_excluded_by_constraints call
so that it is applied to all RTEs not just plain tables.  With the default
setting of constraint_exclusion this results in no extra work, but with
constraint_exclusion = ON we will detect optimizations that we missed
before (at the cost of more planner cycles than we expended before).

Per a gripe from Gunnlaugur Þór Briem.  Experimentation with
his example also showed we were not being very bright about the case where
constraint exclusion is proven within a subquery within UNION ALL, so tweak
the code to allow set_append_rel_pathlist to recognize such cases.

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index b42148182876d388de8487080b7c33c7f64ac748..815b996a131d82baa419a2228ac1d7fb51f075d1 100644 (file)
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -171,7 +171,18 @@ static void
 set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
                                 Index rti, RangeTblEntry *rte)
 {
-       if (rte->inh)
+       if (rel->reloptkind == RELOPT_BASEREL &&
+               relation_excluded_by_constraints(root, rel, rte))
+       {
+               /*
+                * We proved we don't need to scan the rel via constraint exclusion,
+                * so set up a single dummy path for it.  Here we only check this for
+                * regular baserels; if it's an otherrel, CE was already checked in
+                * set_append_rel_pathlist().
+                */
+               set_dummy_rel_pathlist(rel);
+       }
+       else if (rte->inh)
        {
                /* It's an "append relation", process accordingly */
                set_append_rel_pathlist(root, rel, rti, rte);
@@ -229,19 +240,6 @@ set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
 static void
 set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
 {
-       /*
-        * If we can prove we don't need to scan the rel via constraint exclusion,
-        * set up a single dummy path for it.  We only need to check for regular
-        * baserels; if it's an otherrel, CE was already checked in
-        * set_append_rel_pathlist().
-        */
-       if (rel->reloptkind == RELOPT_BASEREL &&
-               relation_excluded_by_constraints(root, rel, rte))
-       {
-               set_dummy_rel_pathlist(rel);
-               return;
-       }
-
        /*
         * Test any partial indexes of rel for applicability.  We must do this
         * first since partial unique indexes can affect size estimates.
@@ -439,18 +437,29 @@ set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
                 * otherrels.  So we just leave the child's attr_needed empty.
                 */
 
-               /* Remember which childrels are live, for MergeAppend logic below */
-               live_childrels = lappend(live_childrels, childrel);
-
                /*
-                * Compute the child's access paths, and add the cheapest one to the
-                * Append path we are constructing for the parent.
+                * Compute the child's access paths.
                 */
                set_rel_pathlist(root, childrel, childRTindex, childRTE);
 
+               /*
+                * It is possible that constraint exclusion detected a contradiction
+                * within a child subquery, even though we didn't prove one above.
+                * If what we got back was a dummy path, we can skip this child.
+                */
+               if (IS_DUMMY_PATH(childrel->cheapest_total_path))
+                       continue;
+
+               /*
+                * Child is live, so add its cheapest access path to the Append path
+                * we are constructing for the parent.
+                */
                subpaths = accumulate_append_subpath(subpaths,
                                                                                         childrel->cheapest_total_path);
 
+               /* Remember which childrels are live, for MergeAppend logic below */
+               live_childrels = lappend(live_childrels, childrel);
+
                /*
                 * Collect a list of all the available path orderings for all the
                 * children.  We use this as a heuristic to indicate which sort
@@ -793,6 +802,17 @@ set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
                                                                        &subroot);
        rel->subroot = subroot;
 
+       /*
+        * It's possible that constraint exclusion proved the subquery empty.
+        * If so, it's convenient to turn it back into a dummy path so that we
+        * will recognize appropriate optimizations at this level.
+        */
+       if (is_dummy_plan(rel->subplan))
+       {
+               set_dummy_rel_pathlist(rel);
+               return;
+       }
+
        /* Mark rel with estimated output rows, width, etc */
        set_subquery_size_estimates(root, rel);
 

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 64b5eb4d9cc3fc50b3238940d9d2e8331086bf0c..b4982746a2e3fe27e8e59804f3e2473205e6aa17 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -60,7 +60,6 @@ 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 void preprocess_rowmarks(PlannerInfo *root);
 static double preprocess_limit(PlannerInfo *root,
                                 double tuple_fraction,
@@ -1841,9 +1840,11 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
  * is deemed not to need scanning due to constraint exclusion.
  *
  * Currently, such dummy plans are Result nodes with constant FALSE
- * filter quals.
+ * filter quals (see set_dummy_rel_pathlist and create_append_plan).
+ *
+ * XXX this probably ought to be somewhere else, but not clear where.
  */
-static bool
+bool
 is_dummy_plan(Plan *plan)
 {
        if (IsA(plan, Result))

diff --git a/src/include/optimizer/planner.h b/src/include/optimizer/planner.h
index 01fc1fc5d4a997e20192787395581d5a411ad998..77a5a43421d9845f109cfdeaccc4a7d03a9566bd 100644 (file)
--- a/src/include/optimizer/planner.h
+++ b/src/include/optimizer/planner.h
@@ -35,6 +35,8 @@ extern Plan *subquery_planner(PlannerGlobal *glob, Query *parse,
                                 bool hasRecursion, double tuple_fraction,
                                 PlannerInfo **subroot);
 
+extern bool is_dummy_plan(Plan *plan);
+
 extern Expr *expression_planner(Expr *expr);
 
 extern bool plan_cluster_use_sort(Oid tableOid, Oid indexOid);