When testing usability of a partial index, recognize that an index

predicate of the form 'foo IS NOT NULL' is implied by a WHERE clause
that uses 'foo' in any strict operator or function.  Per suggestion
and preliminary implementation by John Siracusa; some further hacking
by moi.

diff --git a/src/backend/optimizer/path/indxpath.c b/src/backend/optimizer/path/indxpath.c
index ecd126da7ffebf7a33e54403058cc09b5e53574c..7d04ef14b7d5fe12e3e7e7cdd26bafd7a8d110a7 100644 (file)
--- a/src/backend/optimizer/path/indxpath.c
+++ b/src/backend/optimizer/path/indxpath.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.156 2004/01/07 22:02:48 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/path/indxpath.c,v 1.157 2004/03/07 05:43:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -965,24 +965,38 @@ static const StrategyNumber
 };
 
 
-/*
+/*----------
  * pred_test_simple_clause
  *       Does the "predicate inclusion test" for a "simple clause" predicate
  *       and a "simple clause" restriction.
  *
- *       We have two strategies for determining whether one simple clause
- *       implies another.      A simple and general way is to see if they are
- *       equal(); this works for any kind of expression.  (Actually, there
- *       is an implied assumption that the functions in the expression are
- *       immutable, ie dependent only on their input arguments --- but this
- *       was checked for the predicate by CheckPredicate().)
+ * We have three strategies for determining whether one simple clause
+ * implies another:
+ *
+ * A simple and general way is to see if they are equal(); this works for any
+ * kind of expression.  (Actually, there is an implied assumption that the
+ * functions in the expression are immutable, ie dependent only on their input
+ * arguments --- but this was checked for the predicate by CheckPredicate().)
  *
- *       Our other way works only for (binary boolean) operators that are
- *       in some btree operator class.  We use the above operator implication
- *       table to be able to derive implications between nonidentical clauses.
+ * When the predicate is of the form "foo IS NOT NULL", we can conclude that
+ * the predicate is implied if the clause is a strict operator or function
+ * that has "foo" as an input.  In this case the clause must yield NULL when
+ * "foo" is NULL, which we can take as equivalent to FALSE because we know
+ * we are within an AND/OR subtree of a WHERE clause.  (Again, "foo" is
+ * already known immutable, so the clause will certainly always fail.)
  *
- *       Eventually, rtree operators could also be handled by defining an
- *       appropriate "RT_implic_table" array.
+ * Our other way works only for binary boolean opclauses of the form
+ * "foo op constant", where "foo" is the same in both clauses.  The operators
+ * and constants can be different but the operators must be in the same btree
+ * operator class.  We use the above operator implication table to be able to
+ * derive implications between nonidentical clauses.  (Note: "foo" is known
+ * immutable, and constants are surely immutable, and we assume that operators
+ * that are in btree opclasses are immutable, so there's no need to do extra
+ * mutability checks in this case either.)
+ *
+ * Eventually, rtree operators could also be handled by defining an
+ * appropriate "RT_implic_table" array.
+ *----------
  */
 static bool
 pred_test_simple_clause(Expr *predicate, Node *clause)
@@ -1020,6 +1034,23 @@ pred_test_simple_clause(Expr *predicate, Node *clause)
        if (equal((Node *) predicate, clause))
                return true;
 
+       /* Next try the IS NOT NULL case */
+       if (predicate && IsA(predicate, NullTest) &&
+               ((NullTest *) predicate)->nulltesttype == IS_NOT_NULL)
+       {
+               Expr *nonnullarg = ((NullTest *) predicate)->arg;
+
+               if (is_opclause(clause) &&
+                       member(nonnullarg, ((OpExpr *) clause)->args) &&
+                       op_strict(((OpExpr *) clause)->opno))
+                       return true;
+               if (is_funcclause(clause) &&
+                       member(nonnullarg, ((FuncExpr *) clause)->args) &&
+                       func_strict(((FuncExpr *) clause)->funcid))
+                       return true;
+               return false;                   /* we can't succeed below... */
+       }
+
        /*
         * Can't do anything more unless they are both binary opclauses with a
         * Const on one side, and identical subexpressions on the other sides.