Extend relation_excluded_by_constraints() to check for mutually

contradictory WHERE-clauses applied to a relation.  This makes the
GUC variable constraint_exclusion rather inappropriately named,
but I've refrained for the moment from renaming it.
Per example from Martin Lesser.

diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index f74faa5c9773afbe60b8d0a271abc169789e85c4..47e39c6a7887d918c7c553d7b755aabbf19b2490 100644 (file)
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/util/plancat.c,v 1.123 2006/08/02 01:59:46 joe Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/util/plancat.c,v 1.124 2006/08/05 00:22:49 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -438,18 +438,42 @@ get_relation_constraints(Oid relationObjectId, RelOptInfo *rel)
 /*
  * relation_excluded_by_constraints
  *
- * Detect whether the relation need not be scanned because it has CHECK
- * constraints that conflict with the query's WHERE clause.
+ * Detect whether the relation need not be scanned because it has either
+ * self-inconsistent restrictions, or restrictions inconsistent with the
+ * relation's CHECK constraints.
  */
 bool
 relation_excluded_by_constraints(RelOptInfo *rel, RangeTblEntry *rte)
 {
+       List       *safe_restrictions;
        List       *constraint_pred;
+       List       *safe_constraints;
+       ListCell   *lc;
 
        /* Skip the test if constraint exclusion is disabled */
        if (!constraint_exclusion)
                return false;
 
+       /*
+        * Check for self-contradictory restriction clauses.  We dare not make
+        * deductions with non-immutable functions, but any immutable clauses that
+        * are self-contradictory allow us to conclude the scan is unnecessary.
+        *
+        * Note: strip off RestrictInfo because predicate_refuted_by() isn't
+        * expecting to see any in its predicate argument.
+        */
+       safe_restrictions = NIL;
+       foreach(lc, rel->baserestrictinfo)
+       {
+               RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+
+               if (!contain_mutable_functions((Node *) rinfo->clause))
+                       safe_restrictions = lappend(safe_restrictions, rinfo->clause);
+       }
+
+       if (predicate_refuted_by(safe_restrictions, safe_restrictions))
+               return true;
+
        /* Only plain relations have constraints */
        if (rte->rtekind != RTE_RELATION || rte->inh)
                return false;
@@ -461,16 +485,29 @@ relation_excluded_by_constraints(RelOptInfo *rel, RangeTblEntry *rte)
         * We do not currently enforce that CHECK constraints contain only
         * immutable functions, so it's necessary to check here. We daren't draw
         * conclusions from plan-time evaluation of non-immutable functions.
+        * Since they're ANDed, we can just ignore any mutable constraints in
+        * the list, and reason about the rest.
         */
-       if (contain_mutable_functions((Node *) constraint_pred))
-               return false;
+       safe_constraints = NIL;
+       foreach(lc, constraint_pred)
+       {
+               Node *pred = (Node *) lfirst(lc);
+
+               if (!contain_mutable_functions(pred))
+                       safe_constraints = lappend(safe_constraints, pred);
+       }
 
        /*
         * The constraints are effectively ANDed together, so we can just try to
         * refute the entire collection at once.  This may allow us to make proofs
         * that would fail if we took them individually.
+        *
+        * Note: we use rel->baserestrictinfo, not safe_restrictions as might
+        * seem an obvious optimization.  Some of the clauses might be OR clauses
+        * that have volatile and nonvolatile subclauses, and it's OK to make
+        * deductions with the nonvolatile parts.
         */
-       if (predicate_refuted_by(constraint_pred, rel->baserestrictinfo))
+       if (predicate_refuted_by(safe_constraints, rel->baserestrictinfo))
                return true;
 
        return false;