Don't return an overoptimistic result from join_in_selectivity when

we have detected that an IN subquery must return unique results.

diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index 3f9416c20ac3a26f3bb793f9d1e8c1e071b99372..454b1db127fec9a26db088d3bf2601b7ab1d2943 100644 (file)
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -49,7 +49,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.122 2004/01/06 04:31:01 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.123 2004/01/19 03:52:28 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -763,9 +763,7 @@ cost_nestloop(NestPath *path, Query *root)
     * an outer tuple as soon as we have one match.  Account for the
     * effects of this by scaling down the cost estimates in proportion to
     * the JOIN_IN selectivity.  (This assumes that all the quals
-    * attached to the join are IN quals, which should be true.)  This would
-    * probably be the wrong approach if an input path is a UniquePath, but
-    * we'd never have that with JOIN_IN join type.
+    * attached to the join are IN quals, which should be true.)
     */
    joininfactor = join_in_selectivity(path, root);
 
@@ -1001,9 +999,7 @@ cost_mergejoin(MergePath *path, Query *root)
     * for an outer tuple as soon as we have one match.  Account for the
     * effects of this by scaling down the cost estimates in proportion to
     * the expected output size.  (This assumes that all the quals
-    * attached to the join are IN quals, which should be true.)  This would
-    * probably be the wrong approach if an input path is a UniquePath, but
-    * we'd never have that with JOIN_IN join type.
+    * attached to the join are IN quals, which should be true.)
     */
    joininfactor = join_in_selectivity(&path->jpath, root);
 
@@ -1208,9 +1204,7 @@ cost_hashjoin(HashPath *path, Query *root)
     * an outer tuple as soon as we have one match.  Account for the
     * effects of this by scaling down the cost estimates in proportion to
     * the expected output size.  (This assumes that all the quals
-    * attached to the join are IN quals, which should be true.)  This would
-    * probably be the wrong approach if an input path is a UniquePath, but
-    * we'd never have that with JOIN_IN join type.
+    * attached to the join are IN quals, which should be true.)
     */
    joininfactor = join_in_selectivity(&path->jpath, root);
 
@@ -1779,12 +1773,31 @@ set_joinrel_size_estimates(Query *root, RelOptInfo *rel,
 static Selectivity
 join_in_selectivity(JoinPath *path, Query *root)
 {
+   RelOptInfo *innerrel;
+   UniquePath *innerunique;
    Selectivity selec;
    double      nrows;
 
+   /* Return 1.0 whenever it's not JOIN_IN */
    if (path->jointype != JOIN_IN)
        return 1.0;
 
+   /*
+    * Return 1.0 if the inner side is already known unique.  The case where
+    * the inner path is already a UniquePath probably cannot happen in
+    * current usage, but check it anyway for completeness.  The interesting
+    * case is where we've determined the inner relation itself is unique,
+    * which we can check by looking at the rows estimate for its UniquePath.
+    */
+   if (IsA(path->innerjoinpath, UniquePath))
+       return 1.0;
+   innerrel = path->innerjoinpath->parent;
+   innerunique = create_unique_path(root,
+                                    innerrel,
+                                    innerrel->cheapest_total_path);
+   if (innerunique->rows >= innerrel->rows)
+       return 1.0;
+
    /*
     * Compute same result set_joinrel_size_estimates would compute
     * for JOIN_INNER.  Note that we use the input rels' absolute size
@@ -1796,8 +1809,7 @@ join_in_selectivity(JoinPath *path, Query *root)
                                   path->joinrestrictinfo,
                                   0,
                                   JOIN_INNER);
-   nrows = path->outerjoinpath->parent->rows *
-       path->innerjoinpath->parent->rows * selec;
+   nrows = path->outerjoinpath->parent->rows * innerrel->rows * selec;
 
    nrows = clamp_row_est(nrows);