Recognize that IN subqueries return already-unique results if they use

UNION/INTERSECT/EXCEPT (without ALL).  This adds on to the previous
optimization for subqueries using DISTINCT.

diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index 5fe12f2b6d5687588386cac2db59d46a4d912656..059685e76aaebd6ca14a161e67e2fd5861ec40df 100644 (file)
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.99 2004/01/05 23:39:54 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.100 2004/01/19 03:49:41 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -33,6 +33,7 @@
 #include "utils/syscache.h"
 
 
+static bool is_distinct_query(Query *query);
 static bool hash_safe_tlist(List *tlist);
 
 
@@ -553,16 +554,14 @@ create_unique_path(Query *root, RelOptInfo *rel, Path *subpath)
    pathnode->subpath = subpath;
 
    /*
-    * If the input is a subquery that uses DISTINCT, we don't need to do
-    * anything; its output is already unique.  (Are there any other cases
-    * in which we can easily prove the input must be distinct?)
+    * If the input is a subquery whose output must be unique already,
+    * we don't need to do anything.
     */
    if (rel->rtekind == RTE_SUBQUERY)
    {
        RangeTblEntry *rte = rt_fetch(rel->relid, root->rtable);
-       Query      *subquery = rte->subquery;
 
-       if (has_distinct_clause(subquery))
+       if (is_distinct_query(rte->subquery))
        {
            pathnode->umethod = UNIQUE_PATH_NOOP;
            pathnode->rows = rel->rows;
@@ -667,6 +666,36 @@ create_unique_path(Query *root, RelOptInfo *rel, Path *subpath)
    return pathnode;
 }
 
+/*
+ * is_distinct_query - does query never return duplicate rows?
+ */
+static bool
+is_distinct_query(Query *query)
+{
+   /* DISTINCT (but not DISTINCT ON) guarantees uniqueness */
+   if (has_distinct_clause(query))
+       return true;
+
+   /* UNION, INTERSECT, EXCEPT guarantee uniqueness, except with ALL */
+   if (query->setOperations)
+   {
+       SetOperationStmt *topop = (SetOperationStmt *) query->setOperations;
+
+       Assert(IsA(topop, SetOperationStmt));
+       Assert(topop->op != SETOP_NONE);
+
+       if (!topop->all)
+           return true;
+   }
+
+   /*
+    * XXX Are there any other cases in which we can easily see the result
+    * must be distinct?
+    */
+
+   return false;
+}
+
 /*
  * hash_safe_tlist - can datatypes of given tlist be hashed?
  *