Add some defenses against constant-FALSE outer join conditions. Since

eval_const_expressions will generally throw away anything that's ANDed with
constant FALSE, what we're left with given an example like

select * from tenk1 a where (unique1,0) in (select unique2,1 from tenk1 b);

is a cartesian product computation, which is really not acceptable.
This is a regression in CVS HEAD compared to previous releases, which were
able to notice the impossible join condition in this case --- though not in
some related cases that are also improved by this patch, such as

select * from tenk1 a left join tenk1 b on (a.unique1=b.unique2 and 0=1);

Fix by skipping evaluation of the appropriate side of the outer join in
cases where it's demonstrably unnecessary.

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index b517f09e003de8e20e8c66699d1ca28c284ce469..9ac0cc9743195f8813f0492f353c7a66ac599cb2 100644 (file)
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/optimizer/path/joinrels.c,v 1.93 2008/08/14 18:47:59 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/optimizer/path/joinrels.c,v 1.94 2008/08/17 19:40:11 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -28,7 +28,8 @@ static List *make_rels_by_clauseless_joins(PlannerInfo *root,
 static bool has_join_restriction(PlannerInfo *root, RelOptInfo *rel);
 static bool has_legal_joinclause(PlannerInfo *root, RelOptInfo *rel);
 static bool is_dummy_rel(RelOptInfo *rel);
-static void mark_dummy_join(RelOptInfo *rel);
+static void mark_dummy_rel(RelOptInfo *rel);
+static bool restriction_is_constant_false(List *restrictlist);
 
 
 /*
@@ -558,15 +559,20 @@ make_join_rel(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
     * this way since it's conceivable that dummy-ness of a multi-element
     * join might only be noticeable for certain construction paths.)
     *
+    * Also, a provably constant-false join restriction typically means that
+    * we can skip evaluating one or both sides of the join.  We do this
+    * by marking the appropriate rel as dummy.
+    *
     * We need only consider the jointypes that appear in join_info_list,
     * plus JOIN_INNER.
     */
    switch (sjinfo->jointype)
    {
        case JOIN_INNER:
-           if (is_dummy_rel(rel1) || is_dummy_rel(rel2))
+           if (is_dummy_rel(rel1) || is_dummy_rel(rel2) ||
+               restriction_is_constant_false(restrictlist))
            {
-               mark_dummy_join(joinrel);
+               mark_dummy_rel(joinrel);
                break;
            }
            add_paths_to_joinrel(root, joinrel, rel1, rel2,
@@ -579,9 +585,12 @@ make_join_rel(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
        case JOIN_LEFT:
            if (is_dummy_rel(rel1))
            {
-               mark_dummy_join(joinrel);
+               mark_dummy_rel(joinrel);
                break;
            }
+           if (restriction_is_constant_false(restrictlist) &&
+               bms_is_subset(rel2->relids, sjinfo->syn_righthand))
+               mark_dummy_rel(rel2);
            add_paths_to_joinrel(root, joinrel, rel1, rel2,
                                 JOIN_LEFT, sjinfo,
                                 restrictlist);
@@ -592,7 +601,7 @@ make_join_rel(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
        case JOIN_FULL:
            if (is_dummy_rel(rel1) && is_dummy_rel(rel2))
            {
-               mark_dummy_join(joinrel);
+               mark_dummy_rel(joinrel);
                break;
            }
            add_paths_to_joinrel(root, joinrel, rel1, rel2,
@@ -603,9 +612,10 @@ make_join_rel(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
                                 restrictlist);
            break;
        case JOIN_SEMI:
-           if (is_dummy_rel(rel1) || is_dummy_rel(rel2))
+           if (is_dummy_rel(rel1) || is_dummy_rel(rel2) ||
+               restriction_is_constant_false(restrictlist))
            {
-               mark_dummy_join(joinrel);
+               mark_dummy_rel(joinrel);
                break;
            }
            add_paths_to_joinrel(root, joinrel, rel1, rel2,
@@ -632,9 +642,12 @@ make_join_rel(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2)
        case JOIN_ANTI:
            if (is_dummy_rel(rel1))
            {
-               mark_dummy_join(joinrel);
+               mark_dummy_rel(joinrel);
                break;
            }
+           if (restriction_is_constant_false(restrictlist) &&
+               bms_is_subset(rel2->relids, sjinfo->syn_righthand))
+               mark_dummy_rel(rel2);
            add_paths_to_joinrel(root, joinrel, rel1, rel2,
                                 JOIN_ANTI, sjinfo,
                                 restrictlist);
@@ -851,10 +864,10 @@ is_dummy_rel(RelOptInfo *rel)
 }
 
 /*
- * Mark a joinrel as proven empty.
+ * Mark a rel as proven empty.
  */
 static void
-mark_dummy_join(RelOptInfo *rel)
+mark_dummy_rel(RelOptInfo *rel)
 {
    /* Set dummy size estimate */
    rel->rows = 0;
@@ -865,10 +878,46 @@ mark_dummy_join(RelOptInfo *rel)
    /* Set up the dummy path */
    add_path(rel, (Path *) create_append_path(rel, NIL));
 
+   /* Set or update cheapest_total_path */
+   set_cheapest(rel);
+}
+
+
+/*
+ * restriction_is_constant_false --- is a restrictlist just FALSE?
+ *
+ * In cases where a qual is provably constant FALSE, eval_const_expressions
+ * will generally have thrown away anything that's ANDed with it.  In outer
+ * join situations this will leave us computing cartesian products only to
+ * decide there's no match for an outer row, which is pretty stupid.  So,
+ * we need to detect the case.
+ */
+static bool
+restriction_is_constant_false(List *restrictlist)
+{
+   ListCell   *lc;
+
    /*
-    * Although set_cheapest will be done again later, we do it immediately
-    * in order to keep is_dummy_rel as cheap as possible (ie, not have
-    * to examine the pathlist).
+    * Despite the above comment, the restriction list we see here might
+    * possibly have other members besides the FALSE constant, since other
+    * quals could get "pushed down" to the outer join level.  So we check
+    * each member of the list.
     */
-   set_cheapest(rel);
+   foreach(lc, restrictlist)
+   {
+       RestrictInfo   *rinfo = (RestrictInfo *) lfirst(lc);
+
+       Assert(IsA(rinfo, RestrictInfo));
+       if (rinfo->clause && IsA(rinfo->clause, Const))
+       {
+           Const  *con = (Const *) rinfo->clause;
+
+           /* constant NULL is as good as constant FALSE for our purposes */
+           if (con->constisnull)
+               return true;
+           if (!DatumGetBool(con->constvalue))
+               return true;
+       }
+   }
+   return false;
 }