Dept. of second thoughts: clause_selectivity shouldn't try to cache its

result for jointypes associated with IN processing.

diff --git a/src/backend/optimizer/path/clausesel.c b/src/backend/optimizer/path/clausesel.c
index a330ce894bb2d54c1ff070a21df3328d8d3f00cf..2cd445961e932d341b42f816a06ebfc22c6ff457 100644 (file)
--- a/src/backend/optimizer/path/clausesel.c
+++ b/src/backend/optimizer/path/clausesel.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.63 2004/01/04 03:51:52 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.64 2004/01/05 16:44:40 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -417,17 +417,38 @@ clause_selectivity(Query *root,
                 * If possible, cache the result of the selectivity calculation for
                 * the clause.  We can cache if varRelid is zero or the clause
                 * contains only vars of that relid --- otherwise varRelid will affect
-                * the result, so mustn't cache.  We ignore the possibility that
-                * jointype will affect the result, which should be okay because outer
-                * join clauses will always be examined with the same jointype value.
+                * the result, so mustn't cache.  We also have to be careful about
+                * the jointype.  It's OK to cache when jointype is JOIN_INNER or
+                * one of the outer join types (any given outer-join clause should
+                * always be examined with the same jointype, so result won't change).
+                * It's not OK to cache when jointype is one of the special types
+                * associated with IN processing, because the same clause may be
+                * examined with different jointypes and the result should vary.
                 */
                if (varRelid == 0 ||
                        bms_is_subset_singleton(rinfo->clause_relids, varRelid))
                {
-                       /* Cacheable --- do we already have the result? */
-                       if (rinfo->this_selec >= 0)
-                               return rinfo->this_selec;
-                       cacheable = true;
+                       switch (jointype)
+                       {
+                               case JOIN_INNER:
+                               case JOIN_LEFT:
+                               case JOIN_FULL:
+                               case JOIN_RIGHT:
+                                       /* Cacheable --- do we already have the result? */
+                                       if (rinfo->this_selec >= 0)
+                                               return rinfo->this_selec;
+                                       cacheable = true;
+                                       break;
+
+                               case JOIN_UNION:
+                                       /* unimplemented anyway... */
+                               case JOIN_IN:
+                               case JOIN_REVERSE_IN:
+                               case JOIN_UNIQUE_OUTER:
+                               case JOIN_UNIQUE_INNER:
+                                       /* unsafe to cache */
+                                       break;
+                       }
                }
 
                /* Proceed with examination of contained clause */