Repair planner failure for cases involving Cartesian products inside

IN (sub-SELECT) constructs.  We must force a clauseless join of the
sub-select member relations, but it wasn't happening because the code
thought it would be able to use the join clause arising from the IN.

diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 26ff2e5758636e16f66cf5281b027d5979658778..50b9aef0110673ea83df0ddd1c9609ddcf85c84a 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.65 2003/12/17 17:07:48 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/optimizer/path/joinrels.c,v 1.66 2004/01/24 00:37:28 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -24,6 +24,7 @@ static List *make_rels_by_clause_joins(Query *root,
 static List *make_rels_by_clauseless_joins(Query *root,
                              RelOptInfo *old_rel,
                              List *other_rels);
+static bool is_inside_IN(Query *root, RelOptInfo *rel);
 
 
 /*
@@ -76,14 +77,26 @@ make_rels_by_joins(Query *root, int level, List **joinrels)
            /*
             * Note that if all available join clauses for this rel
             * require more than one other rel, we will fail to make any
-            * joins against it here.  That's OK; it'll be considered by
-            * "bushy plan" join code in a higher-level pass where we have
-            * those other rels collected into a join rel.  See also the
-            * last-ditch case below.
+            * joins against it here.  In most cases that's OK; it'll be
+            * considered by "bushy plan" join code in a higher-level pass
+            * where we have those other rels collected into a join rel.
             */
            new_rels = make_rels_by_clause_joins(root,
                                                 old_rel,
                                                 other_rels);
+           /*
+            * An exception occurs when there is a clauseless join inside an
+            * IN (sub-SELECT) construct.  Here, the members of the subselect
+            * all have join clauses (against the stuff outside the IN), but
+            * they *must* be joined to each other before we can make use of
+            * those join clauses.  So do the clauseless join bit.
+            *
+            * See also the last-ditch case below.
+            */
+           if (new_rels == NIL && is_inside_IN(root, old_rel))
+               new_rels = make_rels_by_clauseless_joins(root,
+                                                        old_rel,
+                                                        other_rels);
        }
        else
        {
@@ -347,6 +360,29 @@ make_rels_by_clauseless_joins(Query *root,
 }
 
 
+/*
+ * is_inside_IN
+ *     Detect whether the specified relation is inside an IN (sub-SELECT).
+ *
+ * Note that we are actually only interested in rels that have been pulled up
+ * out of an IN, so the routine name is a slight misnomer.
+ */
+static bool
+is_inside_IN(Query *root, RelOptInfo *rel)
+{
+   List       *i;
+
+   foreach(i, root->in_info_list)
+   {
+       InClauseInfo *ininfo = (InClauseInfo *) lfirst(i);
+
+       if (bms_is_subset(rel->relids, ininfo->righthand))
+           return true;
+   }
+   return false;
+}
+
+
 /*
  * make_jointree_rel
  *     Find or build a RelOptInfo join rel representing a specific