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

tglsfdc · tglsfdc · commit 284e4739ef89 · 2005-07-29T21:40:02.000Z
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
@@ -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;

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@`
`25`	`25`	`*`
`26`	`26`	`*`
`27`	`27`	`* IDENTIFICATION`
`28`		`- * $PostgreSQL: pgsql/src/backend/optimizer/prep/prepqual.c,v 1.49 2005/03/28 00:58:23 tgl Exp $`
	`28`	`+ * $PostgreSQL: pgsql/src/backend/optimizer/prep/prepqual.c,v 1.50 2005/07/29 21:40:02 tgl Exp $`
`29`	`29`	`*`
`30`	`30`	`*-------------------------------------------------------------------------`
`31`	`31`	`*/`
`@@ -167,9 +167,6 @@ pull_ors(List *orlist)`
`167`	`167`	`static Expr *`
`168`	`168`	`find_nots(Expr *qual)`
`169`	`169`	`{`
`170`		`- if (qual == NULL)`
`171`		`- return NULL;`
`172`		`-`
`173`	`170`	`if (and_clause((Node *) qual))`
`174`	`171`	`{`
`175`	`172`	`List *t_list = NIL;`
`@@ -204,17 +201,13 @@ find_nots(Expr *qual)`
`204`	`201`	`static Expr *`
`205`	`202`	`push_nots(Expr *qual)`
`206`	`203`	`{`
`207`		`- if (qual == NULL)`
`208`		`- return make_notclause(qual); /* XXX is this right? Or`
`209`		`- * possible? */`
`210`		`-`
`211`		`- /*`
`212`		`- * Negate an operator clause if possible: (NOT (< A B)) => (>= A B)`
`213`		`- * Otherwise, retain the clause as it is (the NOT can't be pushed down`
`214`		`- * any farther).`
`215`		`- */`
`216`	`204`	`if (is_opclause(qual))`
`217`	`205`	`{`
	`206`	`+ /*`
	`207`	`+ * Negate an operator clause if possible: (NOT (< A B)) => (>= A B)`
	`208`	`+ * Otherwise, retain the clause as it is (the NOT can't be pushed down`
	`209`	`+ * any farther).`
	`210`	`+ */`
`218`	`211`	`OpExpr opexpr = (OpExpr ) qual;`
`219`	`212`	`Oid negator = get_negator(opexpr->opno);`
`220`	`213`
`@@ -256,15 +249,16 @@ push_nots(Expr *qual)`
`256`	`249`	`{`
`257`	`250`	`/*`
`258`	`251`	`* Another NOT cancels this NOT, so eliminate the NOT and stop`
`259`		`- * negating this branch.`
	`252`	`+ * negating this branch. But search the subexpression for more`
	`253`	`+ * NOTs to simplify.`
`260`	`254`	`*/`
`261`		`- return get_notclausearg(qual);`
	`255`	`+ return find_nots(get_notclausearg(qual));`
`262`	`256`	`}`
`263`	`257`	`else`
`264`	`258`	`{`
`265`	`259`	`/*`
`266`	`260`	`* We don't know how to negate anything else, place a NOT at this`
`267`		`- * level.`
	`261`	`+ * level. No point in recursing deeper, either.`
`268`	`262`	`*/`
`269`	`263`	`return make_notclause(qual);`
`270`	`264`	`}`
`@@ -303,9 +297,6 @@ push_nots(Expr *qual)`
`303`	`297`	`static Expr *`
`304`	`298`	`find_duplicate_ors(Expr *qual)`
`305`	`299`	`{`
`306`		`- if (qual == NULL)`
`307`		`- return NULL;`
`308`		`-`
`309`	`300`	`if (or_clause((Node *) qual))`
`310`	`301`	`{`
`311`	`302`	`List *orlist = NIL;`