Remove no-longer-helpful reliance on fixed-size local array.

Coverity complained about this code, apparently because it uses a local
array of size FUNC_MAX_ARGS without a guard that the input argument list
is no longer than that.  (Not sure why it complained today, since this
code's been the same for a long time; possibly it re-analyzed everything
the List API change touched?)

Rather than add a guard, though, let's just get rid of the local array
altogether.  It was only there to avoid list_nth() calls, and those are
no longer expensive.

diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c
index 0102c220a4beec4de69338aaa0ab3af3c93e51c4..4f3c59c0a29e5fe7a92eeac59b0347588b9424c5 100644 (file)
--- a/src/backend/parser/parse_func.c
+++ b/src/backend/parser/parse_func.c
@@ -1734,11 +1734,9 @@ unify_hypothetical_args(ParseState *pstate,
                                                Oid *actual_arg_types,
                                                Oid *declared_arg_types)
 {
-       Node       *args[FUNC_MAX_ARGS];
        int                     numDirectArgs,
                                numNonHypotheticalArgs;
-       int                     i;
-       ListCell   *lc;
+       int                     hargpos;
 
        numDirectArgs = list_length(fargs) - numAggregatedArgs;
        numNonHypotheticalArgs = numDirectArgs - numAggregatedArgs;
@@ -1746,25 +1744,20 @@ unify_hypothetical_args(ParseState *pstate,
        if (numNonHypotheticalArgs < 0)
                elog(ERROR, "incorrect number of arguments to hypothetical-set aggregate");
 
-       /* Deconstruct fargs into an array for ease of subscripting */
-       i = 0;
-       foreach(lc, fargs)
-       {
-               args[i++] = (Node *) lfirst(lc);
-       }
-
        /* Check each hypothetical arg and corresponding aggregated arg */
-       for (i = numNonHypotheticalArgs; i < numDirectArgs; i++)
+       for (hargpos = numNonHypotheticalArgs; hargpos < numDirectArgs; hargpos++)
        {
-               int                     aargpos = numDirectArgs + (i - numNonHypotheticalArgs);
+               int                     aargpos = numDirectArgs + (hargpos - numNonHypotheticalArgs);
+               ListCell   *harg = list_nth_cell(fargs, hargpos);
+               ListCell   *aarg = list_nth_cell(fargs, aargpos);
                Oid                     commontype;
 
                /* A mismatch means AggregateCreate didn't check properly ... */
-               if (declared_arg_types[i] != declared_arg_types[aargpos])
+               if (declared_arg_types[hargpos] != declared_arg_types[aargpos])
                        elog(ERROR, "hypothetical-set aggregate has inconsistent declared argument types");
 
                /* No need to unify if make_fn_arguments will coerce */
-               if (declared_arg_types[i] != ANYOID)
+               if (declared_arg_types[hargpos] != ANYOID)
                        continue;
 
                /*
@@ -1773,7 +1766,7 @@ unify_hypothetical_args(ParseState *pstate,
                 * the aggregated values).
                 */
                commontype = select_common_type(pstate,
-                                                                               list_make2(args[aargpos], args[i]),
+                                                                               list_make2(lfirst(aarg), lfirst(harg)),
                                                                                "WITHIN GROUP",
                                                                                NULL);
 
@@ -1781,30 +1774,23 @@ unify_hypothetical_args(ParseState *pstate,
                 * Perform the coercions.  We don't need to worry about NamedArgExprs
                 * here because they aren't supported with aggregates.
                 */
-               args[i] = coerce_type(pstate,
-                                                         args[i],
-                                                         actual_arg_types[i],
-                                                         commontype, -1,
-                                                         COERCION_IMPLICIT,
-                                                         COERCE_IMPLICIT_CAST,
-                                                         -1);
-               actual_arg_types[i] = commontype;
-               args[aargpos] = coerce_type(pstate,
-                                                                       args[aargpos],
-                                                                       actual_arg_types[aargpos],
-                                                                       commontype, -1,
-                                                                       COERCION_IMPLICIT,
-                                                                       COERCE_IMPLICIT_CAST,
-                                                                       -1);
+               lfirst(harg) = coerce_type(pstate,
+                                                                  (Node *) lfirst(harg),
+                                                                  actual_arg_types[hargpos],
+                                                                  commontype, -1,
+                                                                  COERCION_IMPLICIT,
+                                                                  COERCE_IMPLICIT_CAST,
+                                                                  -1);
+               actual_arg_types[hargpos] = commontype;
+               lfirst(aarg) = coerce_type(pstate,
+                                                                  (Node *) lfirst(aarg),
+                                                                  actual_arg_types[aargpos],
+                                                                  commontype, -1,
+                                                                  COERCION_IMPLICIT,
+                                                                  COERCE_IMPLICIT_CAST,
+                                                                  -1);
                actual_arg_types[aargpos] = commontype;
        }
-
-       /* Reconstruct fargs from array */
-       i = 0;
-       foreach(lc, fargs)
-       {
-               lfirst(lc) = args[i++];
-       }
 }