Except_Intersect_Rewrite() failed to ignore resjunk targetlist entries,

thus causing failure if one sub-select had resjunk entries that the other
did not (cf. bug report from Espinosa 4/27/00).

diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c
index 327d8c0aefee4a50c223796ecfe868db55282c5d..8d740ddd9984ab14cd38e2700b6fd68c18feff8f 100644 (file)
--- a/src/backend/rewrite/rewriteHandler.c
+++ b/src/backend/rewrite/rewriteHandler.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.72 2000/04/20 00:31:49 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.73 2000/04/27 20:32:41 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -1542,41 +1542,52 @@ QueryRewrite(Query *parsetree)
 static void
 check_targetlists_are_compatible(List *prev_target, List *current_target)
 {
-       List       *tl,
-                          *next_target;
+       List       *tl;
        int                     prev_len = 0,
                                next_len = 0;
 
        foreach(tl, prev_target)
                if (!((TargetEntry *) lfirst(tl))->resdom->resjunk)
-               prev_len++;
+                       prev_len++;
 
-       foreach(next_target, current_target)
-               if (!((TargetEntry *) lfirst(next_target))->resdom->resjunk)
-               next_len++;
+       foreach(tl, current_target)
+               if (!((TargetEntry *) lfirst(tl))->resdom->resjunk)
+                       next_len++;
 
        if (prev_len != next_len)
                elog(ERROR, "Each UNION | EXCEPT | INTERSECT query must have the same number of columns.");
 
-       foreach(next_target, current_target)
+       foreach(tl, current_target)
        {
-               Oid                     itype;
-               Oid                     otype;
+               TargetEntry        *next_tle = (TargetEntry *) lfirst(tl);
+               TargetEntry        *prev_tle;
+               Oid                             itype;
+               Oid                             otype;
+
+               if (next_tle->resdom->resjunk)
+                       continue;
 
-               otype = ((TargetEntry *) lfirst(prev_target))->resdom->restype;
-               itype = ((TargetEntry *) lfirst(next_target))->resdom->restype;
+               /* This loop must find an entry, since we counted them above. */
+               do
+               {
+                       prev_tle = (TargetEntry *) lfirst(prev_target);
+                       prev_target = lnext(prev_target);
+               } while (prev_tle->resdom->resjunk);
+
+               itype = next_tle->resdom->restype;
+               otype = prev_tle->resdom->restype;
 
                /* one or both is a NULL column? then don't convert... */
                if (otype == InvalidOid)
                {
                        /* propagate a known type forward, if available */
                        if (itype != InvalidOid)
-                               ((TargetEntry *) lfirst(prev_target))->resdom->restype = itype;
+                               prev_tle->resdom->restype = itype;
 #ifdef NOT_USED
                        else
                        {
-                               ((TargetEntry *) lfirst(prev_target))->resdom->restype = UNKNOWNOID;
-                               ((TargetEntry *) lfirst(next_target))->resdom->restype = UNKNOWNOID;
+                               prev_tle->resdom->restype = UNKNOWNOID;
+                               next_tle->resdom->restype = UNKNOWNOID;
                        }
 #endif
                }
@@ -1588,7 +1599,7 @@ check_targetlists_are_compatible(List *prev_target, List *current_target)
                {
                        Node       *expr;
 
-                       expr = ((TargetEntry *) lfirst(next_target))->expr;
+                       expr = next_tle->expr;
                        expr = CoerceTargetExpr(NULL, expr, itype, otype, -1);
                        if (expr == NULL)
                        {
@@ -1597,17 +1608,16 @@ check_targetlists_are_compatible(List *prev_target, List *current_target)
                                         typeidTypeName(itype),
                                         typeidTypeName(otype));
                        }
-                       ((TargetEntry *) lfirst(next_target))->expr = expr;
-                       ((TargetEntry *) lfirst(next_target))->resdom->restype = otype;
+                       next_tle->expr = expr;
+                       next_tle->resdom->restype = otype;
                }
 
                /* both are UNKNOWN? then evaluate as text... */
                else if (itype == UNKNOWNOID)
                {
-                       ((TargetEntry *) lfirst(next_target))->resdom->restype = TEXTOID;
-                       ((TargetEntry *) lfirst(prev_target))->resdom->restype = TEXTOID;
+                       next_tle->resdom->restype = TEXTOID;
+                       prev_tle->resdom->restype = TEXTOID;
                }
-               prev_target = lnext(prev_target);
        }
 }
 
@@ -1645,7 +1655,6 @@ Except_Intersect_Rewrite(Query *parsetree)
                           *sortClause,
                           *distinctClause;
        List       *left_expr,
-                          *right_expr,
                           *resnames = NIL;
        char       *op,
                           *into;
@@ -1664,14 +1673,15 @@ Except_Intersect_Rewrite(Query *parsetree)
         * formulated by the user and he wants the columns named by these
         * strings. The transformation to DNF can cause another Select
         * Statment to be the top one which uses other names for its columns.
-        * Therefore we remeber the original names and attach them to the
+        * Therefore we remember the original names and attach them to the
         * targetlist of the new topmost Node at the end of this function
         */
        foreach(elist, parsetree->targetList)
        {
                TargetEntry *tent = (TargetEntry *) lfirst(elist);
 
-               resnames = lappend(resnames, tent->resdom->resname);
+               if (! tent->resdom->resjunk)
+                       resnames = lappend(resnames, tent->resdom->resname);
        }
 
        /*
@@ -1778,7 +1788,6 @@ Except_Intersect_Rewrite(Query *parsetree)
                if (prev_target)
                        check_targetlists_are_compatible(prev_target, intersect_node->targetList);
                prev_target = intersect_node->targetList;
-               /* End of check for corresponding targetlists */
 
                /*
                 * Transform all nodes remaining into subselects and add them to
@@ -1800,7 +1809,6 @@ Except_Intersect_Rewrite(Query *parsetree)
                                 */
                                check_targetlists_are_compatible(prev_target,
                                                 ((Query *) lfirst(intersect_list))->targetList);
-                               /* End of check for corresponding targetlists */
 
                                n->subselect = lfirst(intersect_list);
                                op = "=";
@@ -1822,7 +1830,6 @@ Except_Intersect_Rewrite(Query *parsetree)
                                 */
                                check_targetlists_are_compatible(prev_target,
                                                                                                 ((Query *) lfirst(((Expr *) lfirst(intersect_list))->args))->targetList);
-                               /* End of check for corresponding targetlists */
 
                                n->subselect = (Node *) lfirst(((Expr *) lfirst(intersect_list))->args);
                                op = "<>";
@@ -1840,7 +1847,8 @@ Except_Intersect_Rewrite(Query *parsetree)
                        {
                                TargetEntry *tent = (TargetEntry *) lfirst(elist);
 
-                               n->lefthand = lappend(n->lefthand, tent->expr);
+                               if (! tent->resdom->resjunk)
+                                       n->lefthand = lappend(n->lefthand, tent->expr);
                        }
 
                        /*
@@ -1849,17 +1857,21 @@ Except_Intersect_Rewrite(Query *parsetree)
                         * involved!)
                         */
                        left_expr = n->lefthand;
-                       right_expr = ((Query *) (n->subselect))->targetList;
                        n->oper = NIL;
 
-                       foreach(elist, left_expr)
+                       foreach(elist, ((Query *) (n->subselect))->targetList)
                        {
-                               Node       *lexpr = lfirst(elist);
-                               TargetEntry *tent = (TargetEntry *) lfirst(right_expr);
+                               TargetEntry *tent = (TargetEntry *) lfirst(elist);
+                               Node       *lexpr;
                                Operator        optup;
                                Form_pg_operator opform;
                                Oper       *newop;
 
+                               if (tent->resdom->resjunk)
+                                       continue;
+
+                               lexpr = lfirst(left_expr);
+
                                optup = oper(op,
                                                         exprType(lexpr),
                                                         exprType(tent->expr),
@@ -1877,9 +1889,11 @@ Except_Intersect_Rewrite(Query *parsetree)
 
                                n->oper = lappend(n->oper, newop);
 
-                               right_expr = lnext(right_expr);
+                               left_expr = lnext(left_expr);
                        }
 
+                       Assert(left_expr == NIL); /* should have used 'em all */
+
                        /*
                         * If the Select Query node has aggregates in use add all the
                         * subselects to the HAVING qual else to the WHERE qual
@@ -1930,6 +1944,9 @@ Except_Intersect_Rewrite(Query *parsetree)
        {
                TargetEntry *tent = (TargetEntry *) lfirst(elist);
 
+               if (tent->resdom->resjunk)
+                       continue;
+
                tent->resdom->resname = lfirst(resnames);
                resnames = lnext(resnames);
        }