The original implementation of polymorphic aggregates didn't really get the

checking of argument compatibility right; although the problem is only exposed
with multiple-input aggregates in which some arguments are polymorphic and
some are not.  Per bug #3852 from Sokolov Yura.

diff --git a/src/backend/catalog/pg_aggregate.c b/src/backend/catalog/pg_aggregate.c
index 66f82e3cb0b4c696a0bc945f16e5ae7705de94f9..87ac8223d9a73de795819aa657f842c051f6a280 100644 (file)
--- a/src/backend/catalog/pg_aggregate.c
+++ b/src/backend/catalog/pg_aggregate.c
@@ -296,7 +296,6 @@ lookup_agg_function(List *fnName,
        FuncDetailCode fdresult;
        AclResult       aclresult;
        int                     i;
-       bool            allPolyArgs = true;
 
        /*
         * func_get_detail looks up the function in the catalogs, does
@@ -322,25 +321,15 @@ lookup_agg_function(List *fnName,
                                                func_signature_string(fnName, nargs, input_types))));
 
        /*
-        * If the given type(s) are all polymorphic, there's nothing we can check.
-        * Otherwise, enforce consistency, and possibly refine the result type.
+        * If there are any polymorphic types involved, enforce consistency, and
+        * possibly refine the result type.  It's OK if the result is still
+        * polymorphic at this point, though.
         */
-       for (i = 0; i < nargs; i++)
-       {
-               if (!IsPolymorphicType(input_types[i]))
-               {
-                       allPolyArgs = false;
-                       break;
-               }
-       }
-
-       if (!allPolyArgs)
-       {
-               *rettype = enforce_generic_type_consistency(input_types,
-                                                                                                       true_oid_array,
-                                                                                                       nargs,
-                                                                                                       *rettype);
-       }
+       *rettype = enforce_generic_type_consistency(input_types,
+                                                                                               true_oid_array,
+                                                                                               nargs,
+                                                                                               *rettype,
+                                                                                               true);
 
        /*
         * func_get_detail will find functions requiring run-time argument type

diff --git a/src/backend/executor/nodeAgg.c b/src/backend/executor/nodeAgg.c
index a99b080e50088af533523a62c4f8a713628b4d15..bad0c9153234649f350308c4a838e50a4d139302 100644 (file)
--- a/src/backend/executor/nodeAgg.c
+++ b/src/backend/executor/nodeAgg.c
@@ -1433,7 +1433,8 @@ ExecInitAgg(Agg *node, EState *estate, int eflags)
                        aggtranstype = enforce_generic_type_consistency(inputTypes,
                                                                                                                        declaredArgTypes,
                                                                                                                        agg_nargs,
-                                                                                                                       aggtranstype);
+                                                                                                                       aggtranstype,
+                                                                                                                       false);
                        pfree(declaredArgTypes);
                }
 

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 5a11604404b8e3598d8e32b98ccb9611a5d2f784..fb4ab8799c63cd40ee040ba868520b9a3f4f3b1f 100644 (file)
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -448,7 +448,8 @@ count_agg_clauses_walker(Node *node, AggClauseCounts *counts)
                        aggtranstype = enforce_generic_type_consistency(inputTypes,
                                                                                                                        declaredArgTypes,
                                                                                                                        agg_nargs,
-                                                                                                                       aggtranstype);
+                                                                                                                       aggtranstype,
+                                                                                                                       false);
                        pfree(declaredArgTypes);
                }
 

diff --git a/src/backend/parser/parse_coerce.c b/src/backend/parser/parse_coerce.c
index a69feeceddf68ef1eb8c648e29acfd4dd28436ed..03804c79632a4d31e7bfd327a0aeb4226ae92617 100644 (file)
--- a/src/backend/parser/parse_coerce.c
+++ b/src/backend/parser/parse_coerce.c
@@ -1255,12 +1255,20 @@ check_generic_type_consistency(Oid *actual_arg_types,
  *       we add the extra condition that the ANYELEMENT type must not be an array.
  *       (This is a no-op if used in combination with ANYARRAY or ANYENUM, but
  *       is an extra restriction if not.)
+ *
+ * When allow_poly is false, we are not expecting any of the actual_arg_types
+ * to be polymorphic, and we should not return a polymorphic result type
+ * either.  When allow_poly is true, it is okay to have polymorphic "actual"
+ * arg types, and we can return ANYARRAY or ANYELEMENT as the result.  (This
+ * case is currently used only to check compatibility of an aggregate's
+ * declaration with the underlying transfn.)
  */
 Oid
 enforce_generic_type_consistency(Oid *actual_arg_types,
                                                                 Oid *declared_arg_types,
                                                                 int nargs,
-                                                                Oid rettype)
+                                                                Oid rettype,
+                                                                bool allow_poly)
 {
        int                     j;
        bool            have_generics = false;
@@ -1268,9 +1276,6 @@ enforce_generic_type_consistency(Oid *actual_arg_types,
        Oid                     elem_typeid = InvalidOid;
        Oid                     array_typeid = InvalidOid;
        Oid                     array_typelem;
-       bool            have_anyelement = (rettype == ANYELEMENTOID ||
-                                                                  rettype == ANYNONARRAYOID ||
-                                                                  rettype == ANYENUMOID);
        bool            have_anynonarray = (rettype == ANYNONARRAYOID);
        bool            have_anyenum = (rettype == ANYENUMOID);
 
@@ -1287,7 +1292,7 @@ enforce_generic_type_consistency(Oid *actual_arg_types,
                        decl_type == ANYNONARRAYOID ||
                        decl_type == ANYENUMOID)
                {
-                       have_generics = have_anyelement = true;
+                       have_generics = true;
                        if (decl_type == ANYNONARRAYOID)
                                have_anynonarray = true;
                        else if (decl_type == ANYENUMOID)
@@ -1297,6 +1302,8 @@ enforce_generic_type_consistency(Oid *actual_arg_types,
                                have_unknowns = true;
                                continue;
                        }
+                       if (allow_poly && decl_type == actual_type)
+                               continue;               /* no new information here */
                        if (OidIsValid(elem_typeid) && actual_type != elem_typeid)
                                ereport(ERROR,
                                                (errcode(ERRCODE_DATATYPE_MISMATCH),
@@ -1314,6 +1321,8 @@ enforce_generic_type_consistency(Oid *actual_arg_types,
                                have_unknowns = true;
                                continue;
                        }
+                       if (allow_poly && decl_type == actual_type)
+                               continue;               /* no new information here */
                        if (OidIsValid(array_typeid) && actual_type != array_typeid)
                                ereport(ERROR,
                                                (errcode(ERRCODE_DATATYPE_MISMATCH),
@@ -1335,20 +1344,12 @@ enforce_generic_type_consistency(Oid *actual_arg_types,
        /* Get the element type based on the array type, if we have one */
        if (OidIsValid(array_typeid))
        {
-               if (array_typeid == ANYARRAYOID && !have_anyelement)
-               {
-                       /* Special case for ANYARRAY input: okay iff no ANYELEMENT */
-                       array_typelem = InvalidOid;
-               }
-               else
-               {
-                       array_typelem = get_element_type(array_typeid);
-                       if (!OidIsValid(array_typelem))
-                               ereport(ERROR,
-                                               (errcode(ERRCODE_DATATYPE_MISMATCH),
-                                                errmsg("argument declared \"anyarray\" is not an array but type %s",
-                                                               format_type_be(array_typeid))));
-               }
+               array_typelem = get_element_type(array_typeid);
+               if (!OidIsValid(array_typelem))
+                       ereport(ERROR,
+                                       (errcode(ERRCODE_DATATYPE_MISMATCH),
+                                        errmsg("argument declared \"anyarray\" is not an array but type %s",
+                                                       format_type_be(array_typeid))));
 
                if (!OidIsValid(elem_typeid))
                {
@@ -1370,13 +1371,21 @@ enforce_generic_type_consistency(Oid *actual_arg_types,
        }
        else if (!OidIsValid(elem_typeid))
        {
-               /* Only way to get here is if all the generic args are UNKNOWN */
-               ereport(ERROR,
-                               (errcode(ERRCODE_DATATYPE_MISMATCH),
-                                errmsg("could not determine polymorphic type because input has type \"unknown\"")));
+               if (allow_poly)
+               {
+                       array_typeid = ANYARRAYOID;
+                       elem_typeid = ANYELEMENTOID;
+               }
+               else
+               {
+                       /* Only way to get here is if all the generic args are UNKNOWN */
+                       ereport(ERROR,
+                                       (errcode(ERRCODE_DATATYPE_MISMATCH),
+                                        errmsg("could not determine polymorphic type because input has type \"unknown\"")));
+               }
        }
 
-       if (have_anynonarray)
+       if (have_anynonarray && elem_typeid != ANYELEMENTOID)
        {
                /* require the element type to not be an array */
                if (type_is_array(elem_typeid))
@@ -1386,7 +1395,7 @@ enforce_generic_type_consistency(Oid *actual_arg_types,
                                                  format_type_be(elem_typeid))));
        }
 
-       if (have_anyenum)
+       if (have_anyenum && elem_typeid != ANYELEMENTOID)
        {
                /* require the element type to be an enum */
                if (!type_is_enum(elem_typeid))

diff --git a/src/backend/parser/parse_func.c b/src/backend/parser/parse_func.c
index 6f80ce6cf63f881d84936aae46f7d4638d9821ad..132b7249879abc78205cc9a0ef1fb29d06bbf4a5 100644 (file)
--- a/src/backend/parser/parse_func.c
+++ b/src/backend/parser/parse_func.c
@@ -235,7 +235,8 @@ ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
        rettype = enforce_generic_type_consistency(actual_arg_types,
                                                                                           declared_arg_types,
                                                                                           nargs,
-                                                                                          rettype);
+                                                                                          rettype,
+                                                                                          false);
 
        /* perform the necessary typecasting of arguments */
        make_fn_arguments(pstate, fargs, actual_arg_types, declared_arg_types);

diff --git a/src/backend/parser/parse_oper.c b/src/backend/parser/parse_oper.c
index b068233232df3dda4761b2866113a8496af43564..ddb3a171d90dda9bb155b2a7a777efe77898949c 100644 (file)
--- a/src/backend/parser/parse_oper.c
+++ b/src/backend/parser/parse_oper.c
@@ -1006,7 +1006,8 @@ make_scalar_array_op(ParseState *pstate, List *opname,
        rettype = enforce_generic_type_consistency(actual_arg_types,
                                                                                           declared_arg_types,
                                                                                           2,
-                                                                                          opform->oprresult);
+                                                                                          opform->oprresult,
+                                                                                          false);
 
        /*
         * Check that operator result is boolean
@@ -1116,7 +1117,8 @@ make_op_expr(ParseState *pstate, Operator op,
        rettype = enforce_generic_type_consistency(actual_arg_types,
                                                                                           declared_arg_types,
                                                                                           nargs,
-                                                                                          opform->oprresult);
+                                                                                          opform->oprresult,
+                                                                                          false);
 
        /* perform the necessary typecasting of arguments */
        make_fn_arguments(pstate, args, actual_arg_types, declared_arg_types);

diff --git a/src/include/parser/parse_coerce.h b/src/include/parser/parse_coerce.h
index 5e541bca0d849ca4b8f5a96d24bed42bf1420305..97822ed1fdf6cf4d6c4ecc6ee62e3f94f6932fe9 100644 (file)
--- a/src/include/parser/parse_coerce.h
+++ b/src/include/parser/parse_coerce.h
@@ -81,7 +81,8 @@ extern bool check_generic_type_consistency(Oid *actual_arg_types,
 extern Oid enforce_generic_type_consistency(Oid *actual_arg_types,
                                                                 Oid *declared_arg_types,
                                                                 int nargs,
-                                                                Oid rettype);
+                                                                Oid rettype,
+                                                                bool allow_poly);
 extern Oid resolve_generic_type(Oid declared_type,
                                         Oid context_actual_type,
                                         Oid context_declared_type);

diff --git a/src/test/regress/expected/polymorphism.out b/src/test/regress/expected/polymorphism.out
index de393a052880ec75e1928f9417f06b7013c4139f..a208203c6d39881a911919f9a221ce5c0e96a7b0 100644 (file)
--- a/src/test/regress/expected/polymorphism.out
+++ b/src/test/regress/expected/polymorphism.out
@@ -577,3 +577,39 @@ select q2, sql_if(q2 > 0, q2, q2 + 1) from int8_tbl;
  -4567890123456789 | -4567890123456788
 (5 rows)
 
+-- another kind of polymorphic aggregate
+create function add_group(grp anyarray, ad anyelement, size integer)
+  returns anyarray
+  as $$
+begin
+  if grp is null then
+    return array[ad];
+  end if;
+  if array_upper(grp, 1) < size then
+    return grp || ad;
+  end if;
+  return grp;
+end;
+$$
+  language plpgsql immutable;
+create aggregate build_group(anyelement, integer) (
+  SFUNC = add_group,
+  STYPE = anyarray
+);
+select build_group(q1,3) from int8_tbl;
+        build_group         
+----------------------------
+ {123,123,4567890123456789}
+(1 row)
+
+-- this should fail because stype isn't compatible with arg
+create aggregate build_group(int8, integer) (
+  SFUNC = add_group,
+  STYPE = int2[]
+);
+ERROR:  function add_group(smallint[], bigint, integer) does not exist
+-- but we can make a non-poly agg from a poly sfunc if types are OK
+create aggregate build_group(int8, integer) (
+  SFUNC = add_group,
+  STYPE = int8[]
+);

diff --git a/src/test/regress/sql/polymorphism.sql b/src/test/regress/sql/polymorphism.sql
index c2bf14b48f007969c8388f314c0dd1aeaaa45f20..2df963952f4e2ff9583a5ad63a4520cbb6df3d51 100644 (file)
--- a/src/test/regress/sql/polymorphism.sql
+++ b/src/test/regress/sql/polymorphism.sql
@@ -390,3 +390,39 @@ select case when $1 then $2 else $3 end $$ language sql;
 select f1, sql_if(f1 > 0, bleat(f1), bleat(f1 + 1)) from int4_tbl;
 
 select q2, sql_if(q2 > 0, q2, q2 + 1) from int8_tbl;
+
+-- another kind of polymorphic aggregate
+
+create function add_group(grp anyarray, ad anyelement, size integer)
+  returns anyarray
+  as $$
+begin
+  if grp is null then
+    return array[ad];
+  end if;
+  if array_upper(grp, 1) < size then
+    return grp || ad;
+  end if;
+  return grp;
+end;
+$$
+  language plpgsql immutable;
+
+create aggregate build_group(anyelement, integer) (
+  SFUNC = add_group,
+  STYPE = anyarray
+);
+
+select build_group(q1,3) from int8_tbl;
+
+-- this should fail because stype isn't compatible with arg
+create aggregate build_group(int8, integer) (
+  SFUNC = add_group,
+  STYPE = int2[]
+);
+
+-- but we can make a non-poly agg from a poly sfunc if types are OK
+create aggregate build_group(int8, integer) (
+  SFUNC = add_group,
+  STYPE = int8[]
+);