Fix inappropriate attempt to push down qual clauses into a view that

has UNION/INTERSECT/EXCEPT operations.  Per bug report from Ferrier.

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index fa4e1dfd90ad81e329dd5d15b925066524168a7e..7d44c4dcfa070b5dbf48d39ae48f313062e2986d 100644 (file)
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.70 2001/01/24 19:42:57 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.71 2001/02/03 21:17:52 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -101,8 +101,6 @@ set_base_rel_pathlists(Query *root)
        if (rel->issubquery)
        {
            /* Subquery --- generate a separate plan for it */
-           List       *upperrestrictlist;
-           List       *lst;
 
            /*
             * If there are any restriction clauses that have been attached
@@ -118,6 +116,11 @@ set_base_rel_pathlists(Query *root)
             * Currently, we do not push down clauses that contain subselects,
             * mainly because I'm not sure it will work correctly (the
             * subplan hasn't yet transformed sublinks to subselects).
+            * Also, if the subquery contains set ops (UNION/INTERSECT/EXCEPT)
+            * we do not push down any qual clauses, since the planner doesn't
+            * support quals at the top level of a setop.  (With suitable
+            * analysis we could try to push the quals down into the component
+            * queries of the setop, but getting it right is not trivial.)
             * Non-pushed-down clauses will get evaluated as qpquals of
             * the SubqueryScan node.
             *
@@ -125,41 +128,48 @@ set_base_rel_pathlists(Query *root)
             * decision not to push down, because it'd result in a worse
             * plan?
             */
-           upperrestrictlist = NIL;
-           foreach(lst, rel->baserestrictinfo)
+           if (rte->subquery->setOperations == NULL)
            {
-               RestrictInfo   *rinfo = (RestrictInfo *) lfirst(lst);
-               Node           *clause = (Node *) rinfo->clause;
+               /* OK to consider pushing down individual quals */
+               List       *upperrestrictlist = NIL;
+               List       *lst;
 
-               if (contain_subplans(clause))
+               foreach(lst, rel->baserestrictinfo)
                {
-                   /* Keep it in the upper query */
-                   upperrestrictlist = lappend(upperrestrictlist, rinfo);
-               }
-               else
-               {
-                   /*
-                    * We need to replace Vars in the clause (which must
-                    * refer to outputs of the subquery) with copies of the
-                    * subquery's targetlist expressions.  Note that at this
-                    * point, any uplevel Vars in the clause should have been
-                    * replaced with Params, so they need no work.
-                    */
-                   clause = ResolveNew(clause, rti, 0,
-                                       rte->subquery->targetList,
-                                       CMD_SELECT, 0);
-                   rte->subquery->havingQual =
-                       make_and_qual(rte->subquery->havingQual,
-                                     clause);
-                   /*
-                    * We need not change the subquery's hasAggs or
-                    * hasSublinks flags, since we can't be pushing down
-                    * any aggregates that weren't there before, and we
-                    * don't push down subselects at all.
-                    */
+                   RestrictInfo   *rinfo = (RestrictInfo *) lfirst(lst);
+                   Node           *clause = (Node *) rinfo->clause;
+
+                   if (contain_subplans(clause))
+                   {
+                       /* Keep it in the upper query */
+                       upperrestrictlist = lappend(upperrestrictlist, rinfo);
+                   }
+                   else
+                   {
+                       /*
+                        * We need to replace Vars in the clause (which must
+                        * refer to outputs of the subquery) with copies of
+                        * the subquery's targetlist expressions.  Note that
+                        * at this point, any uplevel Vars in the clause
+                        * should have been replaced with Params, so they
+                        * need no work.
+                        */
+                       clause = ResolveNew(clause, rti, 0,
+                                           rte->subquery->targetList,
+                                           CMD_SELECT, 0);
+                       rte->subquery->havingQual =
+                           make_and_qual(rte->subquery->havingQual,
+                                         clause);
+                       /*
+                        * We need not change the subquery's hasAggs or
+                        * hasSublinks flags, since we can't be pushing down
+                        * any aggregates that weren't there before, and we
+                        * don't push down subselects at all.
+                        */
+                   }
                }
+               rel->baserestrictinfo = upperrestrictlist;
            }
-           rel->baserestrictinfo = upperrestrictlist;
 
            /* Generate the plan for the subquery */
            rel->subplan = subquery_planner(rte->subquery,