Fix oversight in check_ungrouped_columns optimization that avoids

unnecessary checks for complex grouping expressions: we cannot check
whether the expressions are simple Vars until after we apply
flatten_join_alias_vars, because in the case of FULL JOIN that routine
can introduce non-Var expressions.  Per example from Joel Knight.

diff --git a/src/backend/parser/parse_agg.c b/src/backend/parser/parse_agg.c
index ab365ac84dd36bbed14a59bb1d7c191c204e77b2..6f85595610d5c546987d0cd1d792ef79df502195 100644 (file)
--- a/src/backend/parser/parse_agg.c
+++ b/src/backend/parser/parse_agg.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/parser/parse_agg.c,v 1.60 2003/11/29 19:51:51 pgsql Exp $
+ *   $PostgreSQL: pgsql/src/backend/parser/parse_agg.c,v 1.61 2004/01/28 07:46:44 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -98,7 +98,7 @@ void
 parseCheckAggregates(ParseState *pstate, Query *qry)
 {
    List       *groupClauses = NIL;
-   bool        have_non_var_grouping = false;
+   bool        have_non_var_grouping;
    List       *lst;
    bool        hasJoinRTEs;
    Node       *clause;
@@ -127,9 +127,7 @@ parseCheckAggregates(ParseState *pstate, Query *qry)
     * No aggregates allowed in GROUP BY clauses, either.
     *
     * While we are at it, build a list of the acceptable GROUP BY
-    * expressions for use by check_ungrouped_columns() (this avoids
-    * repeated scans of the targetlist within the recursive routine...).
-    * And detect whether any of the expressions aren't simple Vars.
+    * expressions for use by check_ungrouped_columns().
     */
    foreach(lst, qry->groupClause)
    {
@@ -144,8 +142,6 @@ parseCheckAggregates(ParseState *pstate, Query *qry)
                    (errcode(ERRCODE_GROUPING_ERROR),
                   errmsg("aggregates not allowed in GROUP BY clause")));
        groupClauses = lcons(expr, groupClauses);
-       if (!IsA(expr, Var))
-           have_non_var_grouping = true;
    }
 
    /*
@@ -170,6 +166,21 @@ parseCheckAggregates(ParseState *pstate, Query *qry)
        groupClauses = (List *) flatten_join_alias_vars(qry,
                                                  (Node *) groupClauses);
 
+   /*
+    * Detect whether any of the grouping expressions aren't simple Vars;
+    * if they're all Vars then we don't have to work so hard in the
+    * recursive scans.  (Note we have to flatten aliases before this.)
+    */
+   have_non_var_grouping = false;
+   foreach(lst, groupClauses)
+   {
+       if (!IsA((Node *) lfirst(lst), Var))
+       {
+           have_non_var_grouping = true;
+           break;
+       }
+   }
+
    /*
     * Check the targetlist and HAVING clause for ungrouped variables.
     */