Allow domains over arrays to match ANYARRAY parameters again.

This use-case was broken in commit 529cb267a6843a6a8190c86b75d091771d99d6a9
of 2010-10-21, in which I commented "For the moment, we just forbid such
matching.  We might later wish to insert an automatic downcast to the
underlying array type, but such a change should also change matching of
domains to ANYELEMENT for consistency".  We still lack consensus about what
to do with ANYELEMENT; but not matching ANYARRAY is a clear loss of
functionality compared to prior releases, so let's go ahead and make that
happen.  Per complaint from Regina Obe and extensive subsequent discussion.

diff --git a/src/backend/parser/parse_coerce.c b/src/backend/parser/parse_coerce.c
index 0418972517eee4df52dbdc8f7807aa8fa528a674..3c5be6bc8887c19dd0b59504700680b8731dece1 100644 (file)
--- a/src/backend/parser/parse_coerce.c
+++ b/src/backend/parser/parse_coerce.c
@@ -143,9 +143,7 @@ coerce_type(ParseState *pstate, Node *node,
        }
        if (targetTypeId == ANYOID ||
                targetTypeId == ANYELEMENTOID ||
-               targetTypeId == ANYNONARRAYOID ||
-               (targetTypeId == ANYARRAYOID && inputTypeId != UNKNOWNOID) ||
-               (targetTypeId == ANYENUMOID && inputTypeId != UNKNOWNOID))
+               targetTypeId == ANYNONARRAYOID)
        {
                /*
                 * Assume can_coerce_type verified that implicit coercion is okay.
@@ -154,15 +152,48 @@ coerce_type(ParseState *pstate, Node *node,
                 * it's OK to treat an UNKNOWN constant as a valid input for a
                 * function accepting ANY, ANYELEMENT, or ANYNONARRAY.  This should be
                 * all right, since an UNKNOWN value is still a perfectly valid Datum.
-                * However an UNKNOWN value is definitely *not* an array, and so we
-                * mustn't accept it for ANYARRAY.  (Instead, we will call anyarray_in
-                * below, which will produce an error.)  Likewise, UNKNOWN input is no
-                * good for ANYENUM.
                 *
-                * NB: we do NOT want a RelabelType here.
+                * NB: we do NOT want a RelabelType here: the exposed type of the
+                * function argument must be its actual type, not the polymorphic
+                * pseudotype.
                 */
                return node;
        }
+       if (targetTypeId == ANYARRAYOID ||
+               targetTypeId == ANYENUMOID)
+       {
+               /*
+                * Assume can_coerce_type verified that implicit coercion is okay.
+                *
+                * These cases are unlike the ones above because the exposed type of
+                * the argument must be an actual array or enum type.  In particular
+                * the argument must *not* be an UNKNOWN constant.  If it is, we just
+                * fall through; below, we'll call anyarray_in or anyenum_in, which
+                * will produce an error.  Also, if what we have is a domain over
+                * array or enum, we have to relabel it to its base type.
+                *
+                * Note: currently, we can't actually see a domain-over-enum here,
+                * since the other functions in this file will not match such a
+                * parameter to ANYENUM.  But that should get changed eventually.
+                */
+               if (inputTypeId != UNKNOWNOID)
+               {
+                       Oid                     baseTypeId = getBaseType(inputTypeId);
+
+                       if (baseTypeId != inputTypeId)
+                       {
+                               RelabelType *r = makeRelabelType((Expr *) node,
+                                                                                                baseTypeId, -1,
+                                                                                                InvalidOid,
+                                                                                                cformat);
+
+                               r->location = location;
+                               return (Node *) r;
+                       }
+                       /* Not a domain type, so return it as-is */
+                       return node;
+               }
+       }
        if (inputTypeId == UNKNOWNOID && IsA(node, Const))
        {
                /*
@@ -1257,6 +1288,11 @@ coerce_to_common_type(ParseState *pstate, Node *node,
  *       (This is a no-op if used in combination with ANYARRAY or ANYENUM, but
  *       is an extra restriction if not.)
  *
+ * Domains over arrays match ANYARRAY, and are immediately flattened to their
+ * base type.  (Thus, for example, we will consider it a match if one ANYARRAY
+ * argument is a domain over int4[] while another one is just int4[].)  Also
+ * notice that such a domain does *not* match ANYNONARRAY.
+ *
  * If we have UNKNOWN input (ie, an untyped literal) for any polymorphic
  * argument, assume it is okay.
  *
@@ -1309,6 +1345,7 @@ check_generic_type_consistency(Oid *actual_arg_types,
                {
                        if (actual_type == UNKNOWNOID)
                                continue;
+                       actual_type = getBaseType(actual_type);         /* flatten domains */
                        if (OidIsValid(array_typeid) && actual_type != array_typeid)
                                return false;
                        array_typeid = actual_type;
@@ -1346,8 +1383,8 @@ check_generic_type_consistency(Oid *actual_arg_types,
 
        if (have_anynonarray)
        {
-               /* require the element type to not be an array */
-               if (type_is_array(elem_typeid))
+               /* require the element type to not be an array or domain over array */
+               if (type_is_array_domain(elem_typeid))
                        return false;
        }
 
@@ -1406,6 +1443,10 @@ check_generic_type_consistency(Oid *actual_arg_types,
  *       (This is a no-op if used in combination with ANYARRAY or ANYENUM, but
  *       is an extra restriction if not.)
  *
+ * Domains over arrays match ANYARRAY arguments, and are immediately flattened
+ * to their base type.  (In particular, if the return type is also ANYARRAY,
+ * we'll set it to the base type not the domain type.)
+ *
  * 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"
@@ -1485,6 +1526,7 @@ enforce_generic_type_consistency(Oid *actual_arg_types,
                        }
                        if (allow_poly && decl_type == actual_type)
                                continue;               /* no new information here */
+                       actual_type = getBaseType(actual_type);         /* flatten domains */
                        if (OidIsValid(array_typeid) && actual_type != array_typeid)
                                ereport(ERROR,
                                                (errcode(ERRCODE_DATATYPE_MISMATCH),
@@ -1557,8 +1599,8 @@ enforce_generic_type_consistency(Oid *actual_arg_types,
 
        if (have_anynonarray && elem_typeid != ANYELEMENTOID)
        {
-               /* require the element type to not be an array */
-               if (type_is_array(elem_typeid))
+               /* require the element type to not be an array or domain over array */
+               if (type_is_array_domain(elem_typeid))
                        ereport(ERROR,
                                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                                   errmsg("type matched to anynonarray is an array type: %s",
@@ -1655,15 +1697,19 @@ resolve_generic_type(Oid declared_type,
        {
                if (context_declared_type == ANYARRAYOID)
                {
-                       /* Use actual type, but it must be an array */
-                       Oid                     array_typelem = get_element_type(context_actual_type);
+                       /*
+                        * Use actual type, but it must be an array; or if it's a domain
+                        * over array, use the base array type.
+                        */
+                       Oid                     context_base_type = getBaseType(context_actual_type);
+                       Oid                     array_typelem = get_element_type(context_base_type);
 
                        if (!OidIsValid(array_typelem))
                                ereport(ERROR,
                                                (errcode(ERRCODE_DATATYPE_MISMATCH),
                                                 errmsg("argument declared \"anyarray\" is not an array but type %s",
-                                                               format_type_be(context_actual_type))));
-                       return context_actual_type;
+                                                               format_type_be(context_base_type))));
+                       return context_base_type;
                }
                else if (context_declared_type == ANYELEMENTOID ||
                                 context_declared_type == ANYNONARRAYOID ||
@@ -1687,13 +1733,14 @@ resolve_generic_type(Oid declared_type,
                if (context_declared_type == ANYARRAYOID)
                {
                        /* Use the element type corresponding to actual type */
-                       Oid                     array_typelem = get_element_type(context_actual_type);
+                       Oid                     context_base_type = getBaseType(context_actual_type);
+                       Oid                     array_typelem = get_element_type(context_base_type);
 
                        if (!OidIsValid(array_typelem))
                                ereport(ERROR,
                                                (errcode(ERRCODE_DATATYPE_MISMATCH),
                                                 errmsg("argument declared \"anyarray\" is not an array but type %s",
-                                                               format_type_be(context_actual_type))));
+                                                               format_type_be(context_base_type))));
                        return array_typelem;
                }
                else if (context_declared_type == ANYELEMENTOID ||
@@ -1796,12 +1843,12 @@ IsBinaryCoercible(Oid srctype, Oid targettype)
 
        /* Also accept any array type as coercible to ANYARRAY */
        if (targettype == ANYARRAYOID)
-               if (type_is_array(srctype))
+               if (type_is_array_domain(srctype))
                        return true;
 
        /* Also accept any non-array type as coercible to ANYNONARRAY */
        if (targettype == ANYNONARRAYOID)
-               if (!type_is_array(srctype))
+               if (!type_is_array_domain(srctype))
                        return true;
 
        /* Also accept any enum type as coercible to ANYENUM */

diff --git a/src/test/regress/expected/domain.out b/src/test/regress/expected/domain.out
index 7d72791e5ef1bb126032e100d0faf209396bfd74..2586b07241e4cec819750156c448436375320a88 100644 (file)
--- a/src/test/regress/expected/domain.out
+++ b/src/test/regress/expected/domain.out
@@ -127,6 +127,16 @@ select testint4arr[1], testchar4arr[2:2] from domarrtest;
              | {{d,e,f}}
 (5 rows)
 
+select array_dims(testint4arr), array_dims(testchar4arr) from domarrtest;
+ array_dims | array_dims 
+------------+------------
+ [1:2]      | [1:2][1:2]
+ [1:2][1:2] | [1:1][1:2]
+ [1:2]      | [1:3][1:2]
+ [1:2]      | [1:2][1:1]
+            | [1:2][1:3]
+(5 rows)
+
 COPY domarrtest FROM stdin;
 COPY domarrtest FROM stdin;    -- fail
 ERROR:  value too long for type character varying(4)
@@ -146,6 +156,32 @@ select * from domarrtest;
 drop table domarrtest;
 drop domain domainint4arr restrict;
 drop domain domainchar4arr restrict;
+create domain dia as int[];
+select '{1,2,3}'::dia;
+   dia   
+---------
+ {1,2,3}
+(1 row)
+
+select array_dims('{1,2,3}'::dia);
+ array_dims 
+------------
+ [1:3]
+(1 row)
+
+select pg_typeof('{1,2,3}'::dia);
+ pg_typeof 
+-----------
+ dia
+(1 row)
+
+select pg_typeof('{1,2,3}'::dia || 42); -- should be int[] not dia
+ pg_typeof 
+-----------
+ integer[]
+(1 row)
+
+drop domain dia;
 create domain dnotnull varchar(15) NOT NULL;
 create domain dnull    varchar(15);
 create domain dcheck   varchar(15) NOT NULL CHECK (VALUE = 'a' OR VALUE = 'c' OR VALUE = 'd');

diff --git a/src/test/regress/sql/domain.sql b/src/test/regress/sql/domain.sql
index 545af6262201772c17a3eb06104d76afe662668b..1cc447b8a242080a5ad334b624efd37b4b9928eb 100644 (file)
--- a/src/test/regress/sql/domain.sql
+++ b/src/test/regress/sql/domain.sql
@@ -87,6 +87,7 @@ INSERT INTO domarrtest values (NULL, '{{"a","b","c"},{"d","e","f"}}');
 INSERT INTO domarrtest values (NULL, '{{"toolong","b","c"},{"d","e","f"}}');
 select * from domarrtest;
 select testint4arr[1], testchar4arr[2:2] from domarrtest;
+select array_dims(testint4arr), array_dims(testchar4arr) from domarrtest;
 
 COPY domarrtest FROM stdin;
 {3,4}  {q,w,e}
@@ -103,6 +104,12 @@ drop table domarrtest;
 drop domain domainint4arr restrict;
 drop domain domainchar4arr restrict;
 
+create domain dia as int[];
+select '{1,2,3}'::dia;
+select array_dims('{1,2,3}'::dia);
+select pg_typeof('{1,2,3}'::dia);
+select pg_typeof('{1,2,3}'::dia || 42); -- should be int[] not dia
+drop domain dia;
 
 create domain dnotnull varchar(15) NOT NULL;
 create domain dnull    varchar(15);