Fix an oversight I introduced on 2003-12-28: find_nots/push_nots should

continue to recurse after eliminating a NOT-below-a-NOT, since the
contained subexpression will now be part of the top-level AND/OR structure
and so deserves to be simplified.  The real-world impact of this is
probably minimal, since it'd require at least three levels of NOT to make
a difference, but it's still a bug.
Also remove some redundant tests for NULL subexpressions.

diff --git a/src/backend/optimizer/prep/prepqual.c b/src/backend/optimizer/prep/prepqual.c
index c153d312fa61056f9911e8cf44c01946367428f5..2c39859a8118a6345f4dbd5803ac1c668e83ff90 100644 (file)
--- a/src/backend/optimizer/prep/prepqual.c
+++ b/src/backend/optimizer/prep/prepqual.c
@@ -25,7 +25,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/prep/prepqual.c,v 1.49 2005/03/28 00:58:23 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/prep/prepqual.c,v 1.50 2005/07/29 21:40:02 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -167,9 +167,6 @@ pull_ors(List *orlist)
 static Expr *
 find_nots(Expr *qual)
 {
-       if (qual == NULL)
-               return NULL;
-
        if (and_clause((Node *) qual))
        {
                List       *t_list = NIL;
@@ -204,17 +201,13 @@ find_nots(Expr *qual)
 static Expr *
 push_nots(Expr *qual)
 {
-       if (qual == NULL)
-               return make_notclause(qual);    /* XXX is this right?  Or
-                                                                                * possible? */
-
-       /*
-        * Negate an operator clause if possible: (NOT (< A B)) => (>= A B)
-        * Otherwise, retain the clause as it is (the NOT can't be pushed down
-        * any farther).
-        */
        if (is_opclause(qual))
        {
+               /*
+                * Negate an operator clause if possible: (NOT (< A B)) => (>= A B)
+                * Otherwise, retain the clause as it is (the NOT can't be pushed down
+                * any farther).
+                */
                OpExpr     *opexpr = (OpExpr *) qual;
                Oid                     negator = get_negator(opexpr->opno);
 
@@ -256,15 +249,16 @@ push_nots(Expr *qual)
        {
                /*
                 * Another NOT cancels this NOT, so eliminate the NOT and stop
-                * negating this branch.
+                * negating this branch.  But search the subexpression for more
+                * NOTs to simplify.
                 */
-               return get_notclausearg(qual);
+               return find_nots(get_notclausearg(qual));
        }
        else
        {
                /*
                 * We don't know how to negate anything else, place a NOT at this
-                * level.
+                * level.  No point in recursing deeper, either.
                 */
                return make_notclause(qual);
        }
@@ -303,9 +297,6 @@ push_nots(Expr *qual)
 static Expr *
 find_duplicate_ors(Expr *qual)
 {
-       if (qual == NULL)
-               return NULL;
-
        if (or_clause((Node *) qual))
        {
                List       *orlist = NIL;