Teach find_nonnullable_rels to handle OR cases: if every arm of an OR

forces a particular relation nonnullable, then we can say that the OR does.
This is worth a little extra trouble since it may allow reduction of
outer joins to plain joins.

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 10a8e80140bdf9d544c1fd71771f450360f3e68a..528f02ed111389beef7c228d18678d0002db662d 100644 (file)
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.233 2007/02/02 00:02:55 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.234 2007/02/16 23:32:08 tgl Exp $
  *
  * HISTORY
  *       AUTHOR                        DATE                    MAJOR EVENT
@@ -974,12 +974,13 @@ contain_nonstrict_functions_walker(Node *node, void *context)
  * the expression to have been AND/OR flattened and converted to implicit-AND
  * format.
  *
- * We don't use expression_tree_walker here because we don't want to
- * descend through very many kinds of nodes; only the ones we can be sure
- * are strict. We can descend through the top level of implicit AND'ing,
- * but not through any explicit ANDs (or ORs) below that, since those are not
- * strict constructs.  The List case handles the top-level implicit AND list
- * as well as lists of arguments to strict operators/functions.
+ * top_level is TRUE while scanning top-level AND/OR structure; here, showing
+ * the result is either FALSE or NULL is good enough.  top_level is FALSE when
+ * we have descended below a NOT or a strict function: now we must be able to
+ * prove that the subexpression goes to NULL.
+ *
+ * We don't use expression_tree_walker here because we don't want to descend
+ * through very many kinds of nodes; only the ones we can be sure are strict.
  */
 Relids
 find_nonnullable_rels(Node *clause)
@@ -991,6 +992,7 @@ static Relids
 find_nonnullable_rels_walker(Node *node, bool top_level)
 {
        Relids          result = NULL;
+       ListCell   *l;
 
        if (node == NULL)
                return NULL;
@@ -1003,8 +1005,15 @@ find_nonnullable_rels_walker(Node *node, bool top_level)
        }
        else if (IsA(node, List))
        {
-               ListCell   *l;
-
+               /*
+                * At top level, we are examining an implicit-AND list: if any of
+                * the arms produces FALSE-or-NULL then the result is FALSE-or-NULL.
+                * If not at top level, we are examining the arguments of a strict
+                * function: if any of them produce NULL then the result of the
+                * function must be NULL.  So in both cases, the set of nonnullable
+                * rels is the union of those found in the arms, and we pass down
+                * the top_level flag unmodified.
+                */
                foreach(l, (List *) node)
                {
                        result = bms_join(result,
@@ -1037,9 +1046,57 @@ find_nonnullable_rels_walker(Node *node, bool top_level)
        {
                BoolExpr   *expr = (BoolExpr *) node;
 
-               /* NOT is strict, others are not */
-               if (expr->boolop == NOT_EXPR)
-                       result = find_nonnullable_rels_walker((Node *) expr->args, false);
+               switch (expr->boolop)
+               {
+                       case AND_EXPR:
+                               /* At top level we can just recurse (to the List case) */
+                               if (top_level)
+                               {
+                                       result = find_nonnullable_rels_walker((Node *) expr->args,
+                                                                                                                 top_level);
+                                       break;
+                               }
+                               /*
+                                * Below top level, even if one arm produces NULL, the result
+                                * could be FALSE (hence not NULL).  However, if *all* the
+                                * arms produce NULL then the result is NULL, so we can
+                                * take the intersection of the sets of nonnullable rels,
+                                * just as for OR.  Fall through to share code.
+                                */
+                               /* FALL THRU */
+                       case OR_EXPR:
+                               /*
+                                * OR is strict if all of its arms are, so we can take the
+                                * intersection of the sets of nonnullable rels for each arm.
+                                * This works for both values of top_level.
+                                */
+                               foreach(l, expr->args)
+                               {
+                                       Relids          subresult;
+
+                                       subresult = find_nonnullable_rels_walker(lfirst(l),
+                                                                                                                        top_level);
+                                       if (result == NULL)                             /* first subresult? */
+                                               result = subresult;
+                                       else
+                                               result = bms_int_members(result, subresult);
+                                       /*
+                                        * If the intersection is empty, we can stop looking.
+                                        * This also justifies the test for first-subresult above.
+                                        */
+                                       if (bms_is_empty(result))
+                                               break;
+                               }
+                               break;
+                       case NOT_EXPR:
+                               /* NOT will return null if its arg is null */
+                               result = find_nonnullable_rels_walker((Node *) expr->args,
+                                                                                                         false);
+                               break;
+                       default:
+                               elog(ERROR, "unrecognized boolop: %d", (int) expr->boolop);
+                               break;
+               }
        }
        else if (IsA(node, RelabelType))
        {
@@ -1056,22 +1113,17 @@ find_nonnullable_rels_walker(Node *node, bool top_level)
        }
        else if (IsA(node, NullTest))
        {
+               /* IS NOT NULL can be considered strict, but only at top level */
                NullTest   *expr = (NullTest *) node;
 
-               /*
-                * IS NOT NULL can be considered strict, but only at top level; else
-                * we might have something like NOT (x IS NOT NULL).
-                */
                if (top_level && expr->nulltesttype == IS_NOT_NULL)
                        result = find_nonnullable_rels_walker((Node *) expr->arg, false);
        }
        else if (IsA(node, BooleanTest))
        {
+               /* Boolean tests that reject NULL are strict at top level */
                BooleanTest *expr = (BooleanTest *) node;
 
-               /*
-                * Appropriate boolean tests are strict at top level.
-                */
                if (top_level &&
                        (expr->booltesttype == IS_TRUE ||
                         expr->booltesttype == IS_FALSE ||