Fix oversight in indexscan plan creation. I recently added code to use

predicate_implied_by() to detect redundant filter conditions, but forgot
that predicate_implied_by() assumes its first argument contains only
immutable functions.  Add a check to guarantee that.  Also, test to see
if filter conditions can be discarded because they are redundant with
the predicate of a partial index.

diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 5ddc5d654de9256a938249364a07abbb2eab1384..8d1d7a2ecad9b8b057a3de246e80c7147b200492 100644 (file)
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.198 2005/09/24 22:54:37 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.199 2005/10/06 16:01:54 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -819,7 +819,9 @@ create_indexscan_plan(PlannerInfo *root,
         * (particularly with OR'd index conditions) we may have scan_clauses
         * that are not equal to, but are logically implied by, the index quals;
         * so we also try a predicate_implied_by() check to see if we can discard
-        * quals that way.
+        * quals that way.  (predicate_implied_by assumes its first input contains
+        * only immutable functions, so we have to check that.)  We can also
+        * discard quals that are implied by a partial index's predicate.
         *
         * While at it, we strip off the RestrictInfos to produce a list of
         * plain expressions.
@@ -832,9 +834,15 @@ create_indexscan_plan(PlannerInfo *root,
                Assert(IsA(rinfo, RestrictInfo));
                if (list_member_ptr(nonlossy_indexquals, rinfo))
                        continue;
-               if (predicate_implied_by(list_make1(rinfo->clause),
-                                                                nonlossy_indexquals))
-                       continue;
+               if (!contain_mutable_functions((Node *) rinfo->clause))
+               {
+                       List    *clausel = list_make1(rinfo->clause);
+
+                       if (predicate_implied_by(clausel, nonlossy_indexquals))
+                               continue;
+                       if (predicate_implied_by(clausel, best_path->indexinfo->indpred))
+                               continue;
+               }
                qpqual = lappend(qpqual, rinfo->clause);
        }
 
@@ -916,6 +924,14 @@ create_bitmap_scan_plan(PlannerInfo *root,
         * OR'd index conditions) we may have scan_clauses that are not equal to,
         * but are logically implied by, the index quals; so we also try a
         * predicate_implied_by() check to see if we can discard quals that way.
+        * (predicate_implied_by assumes its first input contains only immutable
+        * functions, so we have to check that.)  We can also discard quals that
+        * are implied by a partial index's predicate.
+        *
+        * XXX For the moment, we only consider partial index predicates in the
+        * simple single-index-scan case.  Is it worth trying to be smart about
+        * more complex cases?  Perhaps create_bitmap_subplan should be made to
+        * include predicate info in what it constructs.
         */
        qpqual = NIL;
        foreach(l, scan_clauses)
@@ -924,9 +940,20 @@ create_bitmap_scan_plan(PlannerInfo *root,
 
                if (list_member(indexquals, clause))
                        continue;
-               if (predicate_implied_by(list_make1(clause),
-                                                                indexquals))
-                       continue;
+               if (!contain_mutable_functions(clause))
+               {
+                       List    *clausel = list_make1(clause);
+
+                       if (predicate_implied_by(clausel, indexquals))
+                               continue;
+                       if (IsA(best_path->bitmapqual, IndexPath))
+                       {
+                               IndexPath *ipath = (IndexPath *) best_path->bitmapqual;
+
+                               if (predicate_implied_by(clausel, ipath->indexinfo->indpred))
+                                       continue;
+                       }
+               }
                qpqual = lappend(qpqual, clause);
        }
 

diff --git a/src/backend/optimizer/util/predtest.c b/src/backend/optimizer/util/predtest.c
index 9628f9186eb96d65a3b43fa0b283d1065af52eaf..2a0896fa63e0e527466b66eaa61c847741d2e9e0 100644 (file)
--- a/src/backend/optimizer/util/predtest.c
+++ b/src/backend/optimizer/util/predtest.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/util/predtest.c,v 1.2 2005/07/23 21:05:47 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/util/predtest.c,v 1.3 2005/10/06 16:01:55 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -47,7 +47,7 @@ static bool btree_predicate_proof(Expr *predicate, Node *clause,
  * valid, but no worse consequences will ensue.
  *
  * We assume the predicate has already been checked to contain only
- * immutable functions and operators.  (In current use this is true
+ * immutable functions and operators.  (In most current uses this is true
  * because the predicate is part of an index predicate that has passed
  * CheckPredicate().)  We dare not make deductions based on non-immutable
  * functions, because they might change answers between the time we make