Don't try to remove duplicate OR-subclauses in create_bitmap_subplan and

make_restrictinfo_from_bitmapqual.  The likelihood of finding duplicates
seems much less than in the AND-subclause case, and the cost much higher,
because OR lists with hundreds or even thousands of subclauses are not
uncommon.  Per discussion with Ilia Kantor and andrew@supernews.

diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 8d1d7a2ecad9b8b057a3de246e80c7147b200492..b7af04e1b9f6080f7893d9dd6d62bc6013ba946f 100644 (file)
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.199 2005/10/06 16:01:54 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.200 2005/10/13 00:06:46 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1046,9 +1046,13 @@ create_bitmap_subplan(PlannerInfo *root, Path *bitmapqual,
                ListCell   *l;
 
                /*
-                * Here, we detect both obvious redundancies and qual-free subplans.
-                * A qual-free subplan would cause us to generate "... OR true ..."
-                * which we may as well reduce to just "true".
+                * Here, we only detect qual-free subplans.  A qual-free subplan would
+                * cause us to generate "... OR true ..."  which we may as well reduce
+                * to just "true".  We do not try to eliminate redundant subclauses
+                * because (a) it's not as likely as in the AND case, and (b) we might
+                * well be working with hundreds or even thousands of OR conditions,
+                * perhaps from a long IN list.  The performance of list_append_unique
+                * would be unacceptable.
                 */
                foreach(l, opath->bitmapquals)
                {
@@ -1062,13 +1066,13 @@ create_bitmap_subplan(PlannerInfo *root, Path *bitmapqual,
                        if (subqual == NIL)
                                const_true_subqual = true;
                        else if (!const_true_subqual)
-                               subquals = list_append_unique(subquals,
-                                                                                         make_ands_explicit(subqual));
+                               subquals = lappend(subquals,
+                                                                  make_ands_explicit(subqual));
                        if (subindexqual == NIL)
                                const_true_subindexqual = true;
                        else if (!const_true_subindexqual)
-                               subindexquals = list_append_unique(subindexquals,
-                                                                                                  make_ands_explicit(subindexqual));
+                               subindexquals = lappend(subindexquals,
+                                                                               make_ands_explicit(subindexqual));
                }
                plan = (Plan *) make_bitmap_or(subplans);
                plan->startup_cost = opath->path.startup_cost;

diff --git a/src/backend/optimizer/util/restrictinfo.c b/src/backend/optimizer/util/restrictinfo.c
index deb16152fb8bbca952eb31d43f2d31d767ac5b50..47b90aef46a97bb99570b9220736d44353d1a7d7 100644 (file)
--- a/src/backend/optimizer/util/restrictinfo.c
+++ b/src/backend/optimizer/util/restrictinfo.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.39 2005/07/28 20:26:21 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/util/restrictinfo.c,v 1.40 2005/10/13 00:06:46 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -123,9 +123,13 @@ make_restrictinfo_from_bitmapqual(Path *bitmapqual,
                List       *withoutris = NIL;
 
                /*
-                * Here, we detect both obvious redundancies and qual-free subplans.
-                * A qual-free subplan would cause us to generate "... OR true ..."
-                * which we may as well reduce to just "true".
+                * Here, we only detect qual-free subplans.  A qual-free subplan would
+                * cause us to generate "... OR true ..."  which we may as well reduce
+                * to just "true".  We do not try to eliminate redundant subclauses
+                * because (a) it's not as likely as in the AND case, and (b) we might
+                * well be working with hundreds or even thousands of OR conditions,
+                * perhaps from a long IN list.  The performance of list_append_unique
+                * would be unacceptable.
                 */
                foreach(l, opath->bitmapquals)
                {
@@ -144,12 +148,12 @@ make_restrictinfo_from_bitmapqual(Path *bitmapqual,
                                return NIL;
                        }
                        /* Create AND subclause with RestrictInfos */
-                       withris = list_append_unique(withris,
-                                                                                make_ands_explicit(sublist));
+                       withris = lappend(withris,
+                                                         make_ands_explicit(sublist));
                        /* And one without */
                        sublist = get_actual_clauses(sublist);
-                       withoutris = list_append_unique(withoutris,
-                                                                                       make_ands_explicit(sublist));
+                       withoutris = lappend(withoutris,
+                                                                make_ands_explicit(sublist));
                }
 
                /*