Further tweaking of error messages for cases involving attributes &

functions of join or subselect aliases.  It'd be awfully nice if this
code knew for sure whether it was dealing with 'x.f' or 'f(x)' syntax;
maybe we can fix that in a future cycle.

diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c
index 8d2f632f33acb48041e1ea9563070cb28870012f..947dcdcee581f3777a85b062317bab46e2f875c7 100644 (file)
--- a/src/backend/parser/parse_func.c
+++ b/src/backend/parser/parse_func.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.101 2001/03/22 03:59:41 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.102 2001/04/18 22:25:31 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -250,6 +250,7 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
    char       *refname;
    Relation    rd;
    int         nargs = length(fargs);
+   int         argn;
    Func       *funcnode;
    Oid         oid_array[FUNC_MAX_ARGS];
    Oid        *true_oid_array;
@@ -261,6 +262,15 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
    Oid         toid = InvalidOid;
    Expr       *expr;
 
+   /*
+    * Most of the rest of the parser just assumes that functions do
+    * not have more than FUNC_MAX_ARGS parameters.  We have to test
+    * here to protect against array overruns, etc.
+    */
+   if (nargs > FUNC_MAX_ARGS)
+       elog(ERROR, "Cannot pass more than %d arguments to a function",
+            FUNC_MAX_ARGS);
+
    if (fargs)
    {
        first_arg = lfirst(fargs);
@@ -419,7 +429,7 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
     */
    MemSet(oid_array, 0, FUNC_MAX_ARGS * sizeof(Oid));
 
-   nargs = 0;
+   argn = 0;
    foreach(i, fargs)
    {
        Node       *arg = lfirst(i);
@@ -447,14 +457,31 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
            {
 
                /*
-                * We have f(x) or more likely x.f where x is a join and f
-                * is not one of the attribute names of the join (else
-                * we'd have recognized it above).  We don't support
+                * The relation name refers to a join.  We can't support
                 * functions on join tuples (since we don't have a named
                 * type for the join tuples), so error out.
                 */
-               elog(ERROR, "No such attribute or function %s.%s",
-                    refname, funcname);
+               if (nargs == 1)
+               {
+                   /*
+                    * We have f(x) or more likely x.f where x is a join
+                    * and f is not one of the attribute names of the join
+                    * (else we'd have recognized it above).  Give an
+                    * appropriately vague error message.  Would be nicer
+                    * to know which syntax was used...
+                    */
+                   elog(ERROR, "No such attribute or function %s.%s",
+                        refname, funcname);
+               }
+               else
+               {
+                   /*
+                    * There are multiple arguments, so it must be a function
+                    * call.
+                    */
+                   elog(ERROR, "Cannot pass result of join %s to a function",
+                        refname);
+               }
                rte = NULL;     /* keep compiler quiet */
            }
            else
@@ -467,8 +494,8 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
            vnum = RTERangeTablePosn(pstate, rte, &sublevels_up);
 
            /*
-            * for func(relname), the param to the function is the tuple
-            * under consideration.  We build a special VarNode to reflect
+            * The parameter to be passed to the function is the whole tuple
+            * from the relation.  We build a special VarNode to reflect
             * this -- it has varno set to the correct range table entry,
             * but has varattno == 0 to signal that the whole tuple is the
             * argument.  Also, it has typmod set to sizeof(Pointer) to
@@ -477,9 +504,23 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
             */
            if (rte->relname == NULL)
            {
-               /* Here, we have an unrecognized attribute of a sub-select */
-               elog(ERROR, "No such attribute or function %s.%s",
-                    refname, funcname);
+               /*
+                * RTE is a subselect; must fail for lack of a specific type
+                */
+               if (nargs == 1)
+               {
+                   /*
+                    * Here, we probably have an unrecognized attribute of a
+                    * sub-select; again can't tell if it was x.f or f(x)
+                    */
+                   elog(ERROR, "No such attribute or function %s.%s",
+                        refname, funcname);
+               }
+               else
+               {
+                   elog(ERROR, "Cannot pass result of sub-select %s to a function",
+                        refname);
+               }
            }
 
            toid = typenameTypeId(rte->relname);
@@ -498,16 +539,7 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
            /* if attisset is true, we already set toid for the single arg */
        }
 
-       /*
-        * Most of the rest of the parser just assumes that functions do
-        * not have more than FUNC_MAX_ARGS parameters.  We have to test
-        * here to protect against array overruns, etc.
-        */
-       if (nargs >= FUNC_MAX_ARGS)
-           elog(ERROR, "Cannot pass more than %d arguments to a function",
-                FUNC_MAX_ARGS);
-
-       oid_array[nargs++] = toid;
+       oid_array[argn++] = toid;
    }
 
    /*