LCOV - differential code coverage report
Current view: top level - src/backend/parser - parse_coerce.c (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 91.6 % 1035 948 87 948
Current Date: 2024-04-14 14:21:10 Functions: 100.0 % 30 30 30
Baseline: 16@8cea358b128 Branches: 76.0 % 1104 839 265 839
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (240..) days: 91.6 % 1035 948 87 948
Function coverage date bins:
(240..) days: 100.0 % 30 30 30
Branch coverage date bins:
(240..) days: 76.0 % 1104 839 265 839

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : /*-------------------------------------------------------------------------
                                  2                 :                :  *
                                  3                 :                :  * parse_coerce.c
                                  4                 :                :  *      handle type coercions/conversions for parser
                                  5                 :                :  *
                                  6                 :                :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
                                  7                 :                :  * Portions Copyright (c) 1994, Regents of the University of California
                                  8                 :                :  *
                                  9                 :                :  *
                                 10                 :                :  * IDENTIFICATION
                                 11                 :                :  *    src/backend/parser/parse_coerce.c
                                 12                 :                :  *
                                 13                 :                :  *-------------------------------------------------------------------------
                                 14                 :                :  */
                                 15                 :                : #include "postgres.h"
                                 16                 :                : 
                                 17                 :                : #include "catalog/pg_cast.h"
                                 18                 :                : #include "catalog/pg_class.h"
                                 19                 :                : #include "catalog/pg_inherits.h"
                                 20                 :                : #include "catalog/pg_proc.h"
                                 21                 :                : #include "catalog/pg_type.h"
                                 22                 :                : #include "nodes/makefuncs.h"
                                 23                 :                : #include "nodes/nodeFuncs.h"
                                 24                 :                : #include "parser/parse_coerce.h"
                                 25                 :                : #include "parser/parse_relation.h"
                                 26                 :                : #include "parser/parse_type.h"
                                 27                 :                : #include "utils/builtins.h"
                                 28                 :                : #include "utils/datum.h"      /* needed for datumIsEqual() */
                                 29                 :                : #include "utils/fmgroids.h"
                                 30                 :                : #include "utils/lsyscache.h"
                                 31                 :                : #include "utils/syscache.h"
                                 32                 :                : #include "utils/typcache.h"
                                 33                 :                : 
                                 34                 :                : 
                                 35                 :                : static Node *coerce_type_typmod(Node *node,
                                 36                 :                :                                 Oid targetTypeId, int32 targetTypMod,
                                 37                 :                :                                 CoercionContext ccontext, CoercionForm cformat,
                                 38                 :                :                                 int location,
                                 39                 :                :                                 bool hideInputCoercion);
                                 40                 :                : static void hide_coercion_node(Node *node);
                                 41                 :                : static Node *build_coercion_expression(Node *node,
                                 42                 :                :                                        CoercionPathType pathtype,
                                 43                 :                :                                        Oid funcId,
                                 44                 :                :                                        Oid targetTypeId, int32 targetTypMod,
                                 45                 :                :                                        CoercionContext ccontext, CoercionForm cformat,
                                 46                 :                :                                        int location);
                                 47                 :                : static Node *coerce_record_to_complex(ParseState *pstate, Node *node,
                                 48                 :                :                                       Oid targetTypeId,
                                 49                 :                :                                       CoercionContext ccontext,
                                 50                 :                :                                       CoercionForm cformat,
                                 51                 :                :                                       int location);
                                 52                 :                : static bool is_complex_array(Oid typid);
                                 53                 :                : static bool typeIsOfTypedTable(Oid reltypeId, Oid reloftypeId);
                                 54                 :                : 
                                 55                 :                : 
                                 56                 :                : /*
                                 57                 :                :  * coerce_to_target_type()
                                 58                 :                :  *      Convert an expression to a target type and typmod.
                                 59                 :                :  *
                                 60                 :                :  * This is the general-purpose entry point for arbitrary type coercion
                                 61                 :                :  * operations.  Direct use of the component operations can_coerce_type,
                                 62                 :                :  * coerce_type, and coerce_type_typmod should be restricted to special
                                 63                 :                :  * cases (eg, when the conversion is expected to succeed).
                                 64                 :                :  *
                                 65                 :                :  * Returns the possibly-transformed expression tree, or NULL if the type
                                 66                 :                :  * conversion is not possible.  (We do this, rather than ereport'ing directly,
                                 67                 :                :  * so that callers can generate custom error messages indicating context.)
                                 68                 :                :  *
                                 69                 :                :  * pstate - parse state (can be NULL, see coerce_type)
                                 70                 :                :  * expr - input expression tree (already transformed by transformExpr)
                                 71                 :                :  * exprtype - result type of expr
                                 72                 :                :  * targettype - desired result type
                                 73                 :                :  * targettypmod - desired result typmod
                                 74                 :                :  * ccontext, cformat - context indicators to control coercions
                                 75                 :                :  * location - parse location of the coercion request, or -1 if unknown/implicit
                                 76                 :                :  */
                                 77                 :                : Node *
 7656 tgl@sss.pgh.pa.us          78                 :CBC      354597 : coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype,
                                 79                 :                :                       Oid targettype, int32 targettypmod,
                                 80                 :                :                       CoercionContext ccontext,
                                 81                 :                :                       CoercionForm cformat,
                                 82                 :                :                       int location)
                                 83                 :                : {
                                 84                 :                :     Node       *result;
                                 85                 :                :     Node       *origexpr;
                                 86                 :                : 
 7242                            87         [ +  + ]:         354597 :     if (!can_coerce_type(1, &exprtype, &targettype, ccontext))
                                 88                 :            277 :         return NULL;
                                 89                 :                : 
                                 90                 :                :     /*
                                 91                 :                :      * If the input has a CollateExpr at the top, strip it off, perform the
                                 92                 :                :      * coercion, and put a new one back on.  This is annoying since it
                                 93                 :                :      * duplicates logic in coerce_type, but if we don't do this then it's too
                                 94                 :                :      * hard to tell whether coerce_type actually changed anything, and we
                                 95                 :                :      * *must* know that to avoid possibly calling hide_coercion_node on
                                 96                 :                :      * something that wasn't generated by coerce_type.  Note that if there are
                                 97                 :                :      * multiple stacked CollateExprs, we just discard all but the topmost.
                                 98                 :                :      * Also, if the target type isn't collatable, we discard the CollateExpr.
                                 99                 :                :      */
 4486                           100                 :         354320 :     origexpr = expr;
                                101   [ +  -  +  + ]:         354335 :     while (expr && IsA(expr, CollateExpr))
                                102                 :             15 :         expr = (Node *) ((CollateExpr *) expr)->arg;
                                103                 :                : 
 7242                           104                 :         354320 :     result = coerce_type(pstate, expr, exprtype,
                                105                 :                :                          targettype, targettypmod,
                                106                 :                :                          ccontext, cformat, location);
                                107                 :                : 
                                108                 :                :     /*
                                109                 :                :      * If the target is a fixed-length type, it may need a length coercion as
                                110                 :                :      * well as a type coercion.  If we find ourselves adding both, force the
                                111                 :                :      * inner coercion node to implicit display form.
                                112                 :                :      */
                                113                 :         352149 :     result = coerce_type_typmod(result,
                                114                 :                :                                 targettype, targettypmod,
                                115                 :                :                                 ccontext, cformat, location,
                                116   [ +  +  +  + ]:         352149 :                                 (result != expr && !IsA(result, Const)));
                                117                 :                : 
 1098                           118   [ +  +  +  + ]:         352149 :     if (expr != origexpr && type_is_collatable(targettype))
                                119                 :                :     {
                                120                 :                :         /* Reinstall top CollateExpr */
 4486                           121                 :             12 :         CollateExpr *coll = (CollateExpr *) origexpr;
                                122                 :             12 :         CollateExpr *newcoll = makeNode(CollateExpr);
                                123                 :                : 
                                124                 :             12 :         newcoll->arg = (Expr *) result;
                                125                 :             12 :         newcoll->collOid = coll->collOid;
                                126                 :             12 :         newcoll->location = coll->location;
                                127                 :             12 :         result = (Node *) newcoll;
                                128                 :                :     }
                                129                 :                : 
 7242                           130                 :         352149 :     return result;
                                131                 :                : }
                                132                 :                : 
                                133                 :                : 
                                134                 :                : /*
                                135                 :                :  * coerce_type()
                                136                 :                :  *      Convert an expression to a different type.
                                137                 :                :  *
                                138                 :                :  * The caller should already have determined that the coercion is possible;
                                139                 :                :  * see can_coerce_type.
                                140                 :                :  *
                                141                 :                :  * Normally, no coercion to a typmod (length) is performed here.  The caller
                                142                 :                :  * must call coerce_type_typmod as well, if a typmod constraint is wanted.
                                143                 :                :  * (But if the target type is a domain, it may internally contain a
                                144                 :                :  * typmod constraint, which will be applied inside coerce_to_domain.)
                                145                 :                :  * In some cases pg_cast specifies a type coercion function that also
                                146                 :                :  * applies length conversion, and in those cases only, the result will
                                147                 :                :  * already be properly coerced to the specified typmod.
                                148                 :                :  *
                                149                 :                :  * pstate is only used in the case that we are able to resolve the type of
                                150                 :                :  * a previously UNKNOWN Param.  It is okay to pass pstate = NULL if the
                                151                 :                :  * caller does not want type information updated for Params.
                                152                 :                :  *
                                153                 :                :  * Note: this function must not modify the given expression tree, only add
                                154                 :                :  * decoration on top of it.  See transformSetOperationTree, for example.
                                155                 :                :  */
                                156                 :                : Node *
 7656                           157                 :         656067 : coerce_type(ParseState *pstate, Node *node,
                                158                 :                :             Oid inputTypeId, Oid targetTypeId, int32 targetTypeMod,
                                159                 :                :             CoercionContext ccontext, CoercionForm cformat, int location)
                                160                 :                : {
                                161                 :                :     Node       *result;
                                162                 :                :     CoercionPathType pathtype;
                                163                 :                :     Oid         funcId;
                                164                 :                : 
 8788                           165   [ +  +  -  + ]:         656067 :     if (targetTypeId == inputTypeId ||
                                166                 :                :         node == NULL)
                                167                 :                :     {
                                168                 :                :         /* no conversion needed */
 7656                           169                 :         177714 :         return node;
                                170                 :                :     }
 7424                           171   [ +  +  +  + ]:         478353 :     if (targetTypeId == ANYOID ||
 6395                           172         [ +  + ]:         470880 :         targetTypeId == ANYELEMENTOID ||
 1487                           173         [ +  - ]:         463194 :         targetTypeId == ANYNONARRAYOID ||
                                174         [ -  + ]:         463194 :         targetTypeId == ANYCOMPATIBLEOID ||
                                175                 :                :         targetTypeId == ANYCOMPATIBLENONARRAYOID)
                                176                 :                :     {
                                177                 :                :         /*
                                178                 :                :          * Assume can_coerce_type verified that implicit coercion is okay.
                                179                 :                :          *
                                180                 :                :          * Note: by returning the unmodified node here, we are saying that
                                181                 :                :          * it's OK to treat an UNKNOWN constant as a valid input for a
                                182                 :                :          * function accepting one of these pseudotypes.  This should be all
                                183                 :                :          * right, since an UNKNOWN value is still a perfectly valid Datum.
                                184                 :                :          *
                                185                 :                :          * NB: we do NOT want a RelabelType here: the exposed type of the
                                186                 :                :          * function argument must be its actual type, not the polymorphic
                                187                 :                :          * pseudotype.
                                188                 :                :          */
 7424                           189                 :          15159 :         return node;
                                190                 :                :     }
 4694                           191   [ +  +  +  + ]:         463194 :     if (targetTypeId == ANYARRAYOID ||
 4546 heikki.linnakangas@i      192         [ +  + ]:         449178 :         targetTypeId == ANYENUMOID ||
 1487 tgl@sss.pgh.pa.us         193         [ +  + ]:         445192 :         targetTypeId == ANYRANGEOID ||
 1211 akorotkov@postgresql      194         [ +  - ]:         442746 :         targetTypeId == ANYMULTIRANGEOID ||
 1487 tgl@sss.pgh.pa.us         195         [ +  - ]:         442746 :         targetTypeId == ANYCOMPATIBLEARRAYOID ||
 1211 akorotkov@postgresql      196         [ -  + ]:         442746 :         targetTypeId == ANYCOMPATIBLERANGEOID ||
                                197                 :                :         targetTypeId == ANYCOMPATIBLEMULTIRANGEOID)
                                198                 :                :     {
                                199                 :                :         /*
                                200                 :                :          * Assume can_coerce_type verified that implicit coercion is okay.
                                201                 :                :          *
                                202                 :                :          * These cases are unlike the ones above because the exposed type of
                                203                 :                :          * the argument must be an actual array, enum, range, or multirange
                                204                 :                :          * type.  In particular the argument must *not* be an UNKNOWN
                                205                 :                :          * constant.  If it is, we just fall through; below, we'll call the
                                206                 :                :          * pseudotype's input function, which will produce an error.  Also, if
                                207                 :                :          * what we have is a domain over array, enum, range, or multirange, we
                                208                 :                :          * have to relabel it to its base type.
                                209                 :                :          *
                                210                 :                :          * Note: currently, we can't actually see a domain-over-enum here,
                                211                 :                :          * since the other functions in this file will not match such a
                                212                 :                :          * parameter to ANYENUM.  But that should get changed eventually.
                                213                 :                :          */
 4694 tgl@sss.pgh.pa.us         214         [ +  + ]:          20448 :         if (inputTypeId != UNKNOWNOID)
                                215                 :                :         {
                                216                 :          19998 :             Oid         baseTypeId = getBaseType(inputTypeId);
                                217                 :                : 
                                218         [ +  + ]:          19998 :             if (baseTypeId != inputTypeId)
                                219                 :                :             {
                                220                 :             27 :                 RelabelType *r = makeRelabelType((Expr *) node,
                                221                 :                :                                                  baseTypeId, -1,
                                222                 :                :                                                  InvalidOid,
                                223                 :                :                                                  cformat);
                                224                 :                : 
                                225                 :             27 :                 r->location = location;
                                226                 :             27 :                 return (Node *) r;
                                227                 :                :             }
                                228                 :                :             /* Not a domain type, so return it as-is */
                                229                 :          19971 :             return node;
                                230                 :                :         }
                                231                 :                :     }
 7656                           232   [ +  +  +  + ]:         443196 :     if (inputTypeId == UNKNOWNOID && IsA(node, Const))
                                233                 :                :     {
                                234                 :                :         /*
                                235                 :                :          * Input is a string constant with previously undetermined type. Apply
                                236                 :                :          * the target type's typinput function to it to produce a constant of
                                237                 :                :          * the target type.
                                238                 :                :          *
                                239                 :                :          * NOTE: this case cannot be folded together with the other
                                240                 :                :          * constant-input case, since the typinput function does not
                                241                 :                :          * necessarily behave the same as a type conversion function. For
                                242                 :                :          * example, int4's typinput function will reject "1.2", whereas
                                243                 :                :          * float-to-int type conversion will round to integer.
                                244                 :                :          *
                                245                 :                :          * XXX if the typinput function is not immutable, we really ought to
                                246                 :                :          * postpone evaluation of the function call until runtime. But there
                                247                 :                :          * is no way to represent a typinput function call as an expression
                                248                 :                :          * tree, because C-string values are not Datums. (XXX This *is*
                                249                 :                :          * possible as of 7.3, do we want to do it?)
                                250                 :                :          */
 9019                           251                 :         311698 :         Const      *con = (Const *) node;
 9000                           252                 :         311698 :         Const      *newcon = makeNode(Const);
                                253                 :                :         Oid         baseTypeId;
                                254                 :                :         int32       baseTypeMod;
                                255                 :                :         int32       inputTypeMod;
                                256                 :                :         Type        baseType;
                                257                 :                :         ParseCallbackState pcbstate;
                                258                 :                : 
                                259                 :                :         /*
                                260                 :                :          * If the target type is a domain, we want to call its base type's
                                261                 :                :          * input routine, not domain_in().  This is to avoid premature failure
                                262                 :                :          * when the domain applies a typmod: existing input routines follow
                                263                 :                :          * implicit-coercion semantics for length checks, which is not always
                                264                 :                :          * what we want here.  The needed check will be applied properly
                                265                 :                :          * inside coerce_to_domain().
                                266                 :                :          */
 5695                           267                 :         311698 :         baseTypeMod = targetTypeMod;
 6584                           268                 :         311698 :         baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod);
                                269                 :                : 
                                270                 :                :         /*
                                271                 :                :          * For most types we pass typmod -1 to the input routine, because
                                272                 :                :          * existing input routines follow implicit-coercion semantics for
                                273                 :                :          * length checks, which is not always what we want here.  Any length
                                274                 :                :          * constraint will be applied later by our caller.  An exception
                                275                 :                :          * however is the INTERVAL type, for which we *must* pass the typmod
                                276                 :                :          * or it won't be able to obey the bizarre SQL-spec input rules. (Ugly
                                277                 :                :          * as sin, but so is this part of the spec...)
                                278                 :                :          */
 5695                           279         [ +  + ]:         311698 :         if (baseTypeId == INTERVALOID)
                                280                 :           2536 :             inputTypeMod = baseTypeMod;
                                281                 :                :         else
                                282                 :         309162 :             inputTypeMod = -1;
                                283                 :                : 
 3270 noah@leadboat.com         284                 :         311698 :         baseType = typeidType(baseTypeId);
                                285                 :                : 
 6584 tgl@sss.pgh.pa.us         286                 :         311698 :         newcon->consttype = baseTypeId;
 5695                           287                 :         311698 :         newcon->consttypmod = inputTypeMod;
 3270 noah@leadboat.com         288                 :         311698 :         newcon->constcollid = typeTypeCollation(baseType);
                                289                 :         311698 :         newcon->constlen = typeLen(baseType);
                                290                 :         311698 :         newcon->constbyval = typeByVal(baseType);
 9000 tgl@sss.pgh.pa.us         291                 :         311698 :         newcon->constisnull = con->constisnull;
                                292                 :                : 
                                293                 :                :         /*
                                294                 :                :          * We use the original literal's location regardless of the position
                                295                 :                :          * of the coercion.  This is a change from pre-9.2 behavior, meant to
                                296                 :                :          * simplify life for pg_stat_statements.
                                297                 :                :          */
 4401                           298                 :         311698 :         newcon->location = con->location;
                                299                 :                : 
                                300                 :                :         /*
                                301                 :                :          * Set up to point at the constant's text if the input routine throws
                                302                 :                :          * an error.
                                303                 :                :          */
 5704                           304                 :         311698 :         setup_parser_errposition_callback(&pcbstate, pstate, con->location);
                                305                 :                : 
                                306                 :                :         /*
                                307                 :                :          * We assume here that UNKNOWN's internal representation is the same
                                308                 :                :          * as CSTRING.
                                309                 :                :          */
 8768 bruce@momjian.us          310         [ +  + ]:         311698 :         if (!con->constisnull)
 3270 noah@leadboat.com         311                 :         280209 :             newcon->constvalue = stringTypeDatum(baseType,
                                312                 :                :                                                  DatumGetCString(con->constvalue),
                                313                 :                :                                                  inputTypeMod);
                                314                 :                :         else
                                315                 :          31489 :             newcon->constvalue = stringTypeDatum(baseType,
                                316                 :                :                                                  NULL,
                                317                 :                :                                                  inputTypeMod);
                                318                 :                : 
                                319                 :                :         /*
                                320                 :                :          * If it's a varlena value, force it to be in non-expanded
                                321                 :                :          * (non-toasted) format; this avoids any possible dependency on
                                322                 :                :          * external values and improves consistency of representation.
                                323                 :                :          */
 3006 tgl@sss.pgh.pa.us         324   [ +  +  +  + ]:         309417 :         if (!con->constisnull && newcon->constlen == -1)
                                325                 :         142305 :             newcon->constvalue =
                                326                 :         142305 :                 PointerGetDatum(PG_DETOAST_DATUM(newcon->constvalue));
                                327                 :                : 
                                328                 :                : #ifdef RANDOMIZE_ALLOCATED_MEMORY
                                329                 :                : 
                                330                 :                :         /*
                                331                 :                :          * For pass-by-reference data types, repeat the conversion to see if
                                332                 :                :          * the input function leaves any uninitialized bytes in the result. We
                                333                 :                :          * can only detect that reliably if RANDOMIZE_ALLOCATED_MEMORY is
                                334                 :                :          * enabled, so we don't bother testing otherwise.  The reason we don't
                                335                 :                :          * want any instability in the input function is that comparison of
                                336                 :                :          * Const nodes relies on bytewise comparison of the datums, so if the
                                337                 :                :          * input function leaves garbage then subexpressions that should be
                                338                 :                :          * identical may not get recognized as such.  See pgsql-hackers
                                339                 :                :          * discussion of 2008-04-04.
                                340                 :                :          */
                                341                 :                :         if (!con->constisnull && !newcon->constbyval)
                                342                 :                :         {
                                343                 :                :             Datum       val2;
                                344                 :                : 
                                345                 :                :             val2 = stringTypeDatum(baseType,
                                346                 :                :                                    DatumGetCString(con->constvalue),
                                347                 :                :                                    inputTypeMod);
                                348                 :                :             if (newcon->constlen == -1)
                                349                 :                :                 val2 = PointerGetDatum(PG_DETOAST_DATUM(val2));
                                350                 :                :             if (!datumIsEqual(newcon->constvalue, val2, false, newcon->constlen))
                                351                 :                :                 elog(WARNING, "type %s has unstable input conversion for \"%s\"",
                                352                 :                :                      typeTypeName(baseType), DatumGetCString(con->constvalue));
                                353                 :                :         }
                                354                 :                : #endif
                                355                 :                : 
 5704                           356                 :         309417 :         cancel_parser_errposition_callback(&pcbstate);
                                357                 :                : 
 9000                           358                 :         309417 :         result = (Node *) newcon;
                                359                 :                : 
                                360                 :                :         /* If target is a domain, apply constraints. */
 6584                           361         [ +  + ]:         309417 :         if (baseTypeId != targetTypeId)
                                362                 :          13156 :             result = coerce_to_domain(result,
                                363                 :                :                                       baseTypeId, baseTypeMod,
                                364                 :                :                                       targetTypeId,
                                365                 :                :                                       ccontext, cformat, location,
                                366                 :                :                                       false);
                                367                 :                : 
 3270 noah@leadboat.com         368                 :         309417 :         ReleaseSysCache(baseType);
                                369                 :                : 
 7656 tgl@sss.pgh.pa.us         370                 :         309417 :         return result;
                                371                 :                :     }
 5279                           372   [ +  +  +  + ]:         131498 :     if (IsA(node, Param) &&
                                373         [ +  + ]:           6946 :         pstate != NULL && pstate->p_coerce_param_hook != NULL)
                                374                 :                :     {
                                375                 :                :         /*
                                376                 :                :          * Allow the CoerceParamHook to decide what happens.  It can return a
                                377                 :                :          * transformed node (very possibly the same Param node), or return
                                378                 :                :          * NULL to indicate we should proceed with normal coercion.
                                379                 :                :          */
 2411 peter_e@gmx.net           380                 :           4303 :         result = pstate->p_coerce_param_hook(pstate,
                                381                 :                :                                              (Param *) node,
                                382                 :                :                                              targetTypeId,
                                383                 :                :                                              targetTypeMod,
                                384                 :                :                                              location);
 5279 tgl@sss.pgh.pa.us         385         [ +  + ]:           4303 :         if (result)
                                386                 :           4287 :             return result;
                                387                 :                :     }
 4783                           388         [ +  + ]:         127211 :     if (IsA(node, CollateExpr))
                                389                 :                :     {
                                390                 :                :         /*
                                391                 :                :          * If we have a COLLATE clause, we have to push the coercion
                                392                 :                :          * underneath the COLLATE; or discard the COLLATE if the target type
                                393                 :                :          * isn't collatable.  This is really ugly, but there is little choice
                                394                 :                :          * because the above hacks on Consts and Params wouldn't happen
                                395                 :                :          * otherwise.  This kluge has consequences in coerce_to_target_type.
                                396                 :                :          */
 4775                           397                 :           3405 :         CollateExpr *coll = (CollateExpr *) node;
                                398                 :                : 
 1098                           399                 :           3405 :         result = coerce_type(pstate, (Node *) coll->arg,
                                400                 :                :                              inputTypeId, targetTypeId, targetTypeMod,
                                401                 :                :                              ccontext, cformat, location);
                                402         [ +  - ]:           3405 :         if (type_is_collatable(targetTypeId))
                                403                 :                :         {
                                404                 :           3405 :             CollateExpr *newcoll = makeNode(CollateExpr);
                                405                 :                : 
                                406                 :           3405 :             newcoll->arg = (Expr *) result;
                                407                 :           3405 :             newcoll->collOid = coll->collOid;
                                408                 :           3405 :             newcoll->location = coll->location;
                                409                 :           3405 :             result = (Node *) newcoll;
                                410                 :                :         }
                                411                 :           3405 :         return result;
                                412                 :                :     }
 6158                           413                 :         123806 :     pathtype = find_coercion_pathway(targetTypeId, inputTypeId, ccontext,
                                414                 :                :                                      &funcId);
                                415         [ +  + ]:         123806 :     if (pathtype != COERCION_PATH_NONE)
                                416                 :                :     {
                                417         [ +  + ]:         122159 :         if (pathtype != COERCION_PATH_RELABELTYPE)
                                418                 :                :         {
                                419                 :                :             /*
                                420                 :                :              * Generate an expression tree representing run-time application
                                421                 :                :              * of the conversion function.  If we are dealing with a domain
                                422                 :                :              * target type, the conversion function will yield the base type,
                                423                 :                :              * and we need to extract the correct typmod to use from the
                                424                 :                :              * domain's typtypmod.
                                425                 :                :              */
                                426                 :                :             Oid         baseTypeId;
                                427                 :                :             int32       baseTypeMod;
                                428                 :                : 
 6584                           429                 :          42998 :             baseTypeMod = targetTypeMod;
                                430                 :          42998 :             baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod);
                                431                 :                : 
 6158                           432                 :          42998 :             result = build_coercion_expression(node, pathtype, funcId,
                                433                 :                :                                                baseTypeId, baseTypeMod,
                                434                 :                :                                                ccontext, cformat, location);
                                435                 :                : 
                                436                 :                :             /*
                                437                 :                :              * If domain, coerce to the domain type and relabel with domain
                                438                 :                :              * type ID, hiding the previous coercion node.
                                439                 :                :              */
 7896                           440         [ +  + ]:          42998 :             if (targetTypeId != baseTypeId)
 6584                           441                 :           1012 :                 result = coerce_to_domain(result, baseTypeId, baseTypeMod,
                                442                 :                :                                           targetTypeId,
                                443                 :                :                                           ccontext, cformat, location,
                                444                 :                :                                           true);
                                445                 :                :         }
                                446                 :                :         else
                                447                 :                :         {
                                448                 :                :             /*
                                449                 :                :              * We don't need to do a physical conversion, but we do need to
                                450                 :                :              * attach a RelabelType node so that the expression will be seen
                                451                 :                :              * to have the intended type when inspected by higher-level code.
                                452                 :                :              *
                                453                 :                :              * Also, domains may have value restrictions beyond the base type
                                454                 :                :              * that must be accounted for.  If the destination is a domain
                                455                 :                :              * then we won't need a RelabelType node.
                                456                 :                :              */
                                457                 :          79161 :             result = coerce_to_domain(node, InvalidOid, -1, targetTypeId,
                                458                 :                :                                       ccontext, cformat, location,
                                459                 :                :                                       false);
 7741                           460         [ +  + ]:          79161 :             if (result == node)
                                461                 :                :             {
                                462                 :                :                 /*
                                463                 :                :                  * XXX could we label result with exprTypmod(node) instead of
                                464                 :                :                  * default -1 typmod, to save a possible length-coercion
                                465                 :                :                  * later? Would work if both types have same interpretation of
                                466                 :                :                  * typmod, which is likely but not certain.
                                467                 :                :                  */
 5708                           468                 :          60882 :                 RelabelType *r = makeRelabelType((Expr *) result,
                                469                 :                :                                                  targetTypeId, -1,
                                470                 :                :                                                  InvalidOid,
                                471                 :                :                                                  cformat);
                                472                 :                : 
                                473                 :          60882 :                 r->location = location;
                                474                 :          60882 :                 result = (Node *) r;
                                475                 :                :             }
                                476                 :                :         }
 7656                           477                 :         122159 :         return result;
                                478                 :                :     }
 7279                           479   [ +  +  +  - ]:           2582 :     if (inputTypeId == RECORDOID &&
                                480                 :            935 :         ISCOMPLEX(targetTypeId))
                                481                 :                :     {
                                482                 :                :         /* Coerce a RECORD to a specific complex type */
                                483                 :            935 :         return coerce_record_to_complex(pstate, node, targetTypeId,
                                484                 :                :                                         ccontext, cformat, location);
                                485                 :                :     }
 6919                           486   [ +  +  +  - ]:           1386 :     if (targetTypeId == RECORDOID &&
                                487                 :            674 :         ISCOMPLEX(inputTypeId))
                                488                 :                :     {
                                489                 :                :         /* Coerce a specific complex type to RECORD */
                                490                 :                :         /* NB: we do NOT want a RelabelType here */
                                491                 :            674 :         return node;
                                492                 :                :     }
                                493                 :                : #ifdef NOT_USED
                                494                 :                :     if (inputTypeId == RECORDARRAYOID &&
                                495                 :                :         is_complex_array(targetTypeId))
                                496                 :                :     {
                                497                 :                :         /* Coerce record[] to a specific complex array type */
                                498                 :                :         /* not implemented yet ... */
                                499                 :                :     }
                                500                 :                : #endif
 5662                           501   [ +  +  +  - ]:             46 :     if (targetTypeId == RECORDARRAYOID &&
                                502                 :              8 :         is_complex_array(inputTypeId))
                                503                 :                :     {
                                504                 :                :         /* Coerce a specific complex array type to record[] */
                                505                 :                :         /* NB: we do NOT want a RelabelType here */
                                506                 :              8 :         return node;
                                507                 :                :     }
 4852 peter_e@gmx.net           508         [ +  + ]:             30 :     if (typeInheritsFrom(inputTypeId, targetTypeId)
                                509         [ +  - ]:              3 :         || typeIsOfTypedTable(inputTypeId, targetTypeId))
                                510                 :                :     {
                                511                 :                :         /*
                                512                 :                :          * Input class type is a subclass of target, so generate an
                                513                 :                :          * appropriate runtime conversion (removing unneeded columns and
                                514                 :                :          * possibly rearranging the ones that are wanted).
                                515                 :                :          *
                                516                 :                :          * We will also get here when the input is a domain over a subclass of
                                517                 :                :          * the target type.  To keep life simple for the executor, we define
                                518                 :                :          * ConvertRowtypeExpr as only working between regular composite types;
                                519                 :                :          * therefore, in such cases insert a RelabelType to smash the input
                                520                 :                :          * expression down to its base type.
                                521                 :                :          */
 2362 tgl@sss.pgh.pa.us         522                 :             30 :         Oid         baseTypeId = getBaseType(inputTypeId);
 7064                           523                 :             30 :         ConvertRowtypeExpr *r = makeNode(ConvertRowtypeExpr);
                                524                 :                : 
 2362                           525         [ -  + ]:             30 :         if (baseTypeId != inputTypeId)
                                526                 :                :         {
 2362 tgl@sss.pgh.pa.us         527                 :UBC           0 :             RelabelType *rt = makeRelabelType((Expr *) node,
                                528                 :                :                                               baseTypeId, -1,
                                529                 :                :                                               InvalidOid,
                                530                 :                :                                               COERCE_IMPLICIT_CAST);
                                531                 :                : 
                                532                 :              0 :             rt->location = location;
                                533                 :              0 :             node = (Node *) rt;
                                534                 :                :         }
 7064 tgl@sss.pgh.pa.us         535                 :CBC          30 :         r->arg = (Expr *) node;
                                536                 :             30 :         r->resulttype = targetTypeId;
                                537                 :             30 :         r->convertformat = cformat;
 5708                           538                 :             30 :         r->location = location;
 7064                           539                 :             30 :         return (Node *) r;
                                540                 :                :     }
                                541                 :                :     /* If we get here, caller blew it */
 7575 tgl@sss.pgh.pa.us         542         [ #  # ]:UBC           0 :     elog(ERROR, "failed to find conversion function from %s to %s",
                                543                 :                :          format_type_be(inputTypeId), format_type_be(targetTypeId));
                                544                 :                :     return NULL;                /* keep compiler quiet */
                                545                 :                : }
                                546                 :                : 
                                547                 :                : 
                                548                 :                : /*
                                549                 :                :  * can_coerce_type()
                                550                 :                :  *      Can input_typeids be coerced to target_typeids?
                                551                 :                :  *
                                552                 :                :  * We must be told the context (CAST construct, assignment, implicit coercion)
                                553                 :                :  * as this determines the set of available casts.
                                554                 :                :  */
                                555                 :                : bool
 2000 peter_e@gmx.net           556                 :CBC      921000 : can_coerce_type(int nargs, const Oid *input_typeids, const Oid *target_typeids,
                                557                 :                :                 CoercionContext ccontext)
                                558                 :                : {
 7677 tgl@sss.pgh.pa.us         559                 :         921000 :     bool        have_generics = false;
                                560                 :                :     int         i;
                                561                 :                : 
                                562                 :                :     /* run through argument list... */
 9472 lockhart@fourpalms.o      563         [ +  + ]:        1632834 :     for (i = 0; i < nargs; i++)
                                564                 :                :     {
 8768 bruce@momjian.us          565                 :        1047765 :         Oid         inputTypeId = input_typeids[i];
 7879 tgl@sss.pgh.pa.us         566                 :        1047765 :         Oid         targetTypeId = target_typeids[i];
                                567                 :                :         CoercionPathType pathtype;
                                568                 :                :         Oid         funcId;
                                569                 :                : 
                                570                 :                :         /* no problem if same type */
 8795                           571         [ +  + ]:        1047765 :         if (inputTypeId == targetTypeId)
                                572                 :         711834 :             continue;
                                573                 :                : 
                                574                 :                :         /* accept if target is ANY */
 7906                           575         [ +  + ]:         810660 :         if (targetTypeId == ANYOID)
                                576                 :           4873 :             continue;
                                577                 :                : 
                                578                 :                :         /* accept if target is polymorphic, for now */
 6222                           579   [ +  +  +  +  :         805787 :         if (IsPolymorphicType(targetTypeId))
                                     +  +  +  +  +  
                                     +  +  +  +  +  
                                     +  +  +  +  +  
                                           +  +  + ]
                                580                 :                :         {
 2489                           581                 :          89692 :             have_generics = true;   /* do more checking later */
 7677                           582                 :          89692 :             continue;
                                583                 :                :         }
                                584                 :                : 
                                585                 :                :         /*
                                586                 :                :          * If input is an untyped string constant, assume we can convert it to
                                587                 :                :          * anything.
                                588                 :                :          */
 7424                           589         [ +  + ]:         716095 :         if (inputTypeId == UNKNOWNOID)
                                590                 :         271246 :             continue;
                                591                 :                : 
                                592                 :                :         /*
                                593                 :                :          * If pg_cast shows that we can coerce, accept.  This test now covers
                                594                 :                :          * both binary-compatible and coercion-function cases.
                                595                 :                :          */
 6158                           596                 :         444849 :         pathtype = find_coercion_pathway(targetTypeId, inputTypeId, ccontext,
                                597                 :                :                                          &funcId);
                                598         [ +  + ]:         444849 :         if (pathtype != COERCION_PATH_NONE)
 7906                           599                 :         107422 :             continue;
                                600                 :                : 
                                601                 :                :         /*
                                602                 :                :          * If input is RECORD and target is a composite type, assume we can
                                603                 :                :          * coerce (may need tighter checking here)
                                604                 :                :          */
 7279                           605   [ +  +  +  + ]:         338431 :         if (inputTypeId == RECORDOID &&
                                606                 :           1004 :             ISCOMPLEX(targetTypeId))
                                607                 :            935 :             continue;
                                608                 :                : 
                                609                 :                :         /*
                                610                 :                :          * If input is a composite type and target is RECORD, accept
                                611                 :                :          */
 6919                           612   [ +  +  +  + ]:         341974 :         if (targetTypeId == RECORDOID &&
                                613                 :           5482 :             ISCOMPLEX(inputTypeId))
                                614                 :            531 :             continue;
                                615                 :                : 
                                616                 :                : #ifdef NOT_USED                 /* not implemented yet */
                                617                 :                : 
                                618                 :                :         /*
                                619                 :                :          * If input is record[] and target is a composite array type, assume
                                620                 :                :          * we can coerce (may need tighter checking here)
                                621                 :                :          */
                                622                 :                :         if (inputTypeId == RECORDARRAYOID &&
                                623                 :                :             is_complex_array(targetTypeId))
                                624                 :                :             continue;
                                625                 :                : #endif
                                626                 :                : 
                                627                 :                :         /*
                                628                 :                :          * If input is a composite array type and target is record[], accept
                                629                 :                :          */
 5662                           630   [ +  +  -  + ]:         335967 :         if (targetTypeId == RECORDARRAYOID &&
                                631                 :              6 :             is_complex_array(inputTypeId))
 5662 tgl@sss.pgh.pa.us         632                 :UBC           0 :             continue;
                                633                 :                : 
                                634                 :                :         /*
                                635                 :                :          * If input is a class type that inherits from target, accept
                                636                 :                :          */
 4852 peter_e@gmx.net           637         [ +  + ]:CBC      335961 :         if (typeInheritsFrom(inputTypeId, targetTypeId)
                                638         [ +  + ]:         335934 :             || typeIsOfTypedTable(inputTypeId, targetTypeId))
 8795 tgl@sss.pgh.pa.us         639                 :             30 :             continue;
                                640                 :                : 
                                641                 :                :         /*
                                642                 :                :          * Else, cannot coerce at this argument position
                                643                 :                :          */
 7896                           644                 :         335931 :         return false;
                                645                 :                :     }
                                646                 :                : 
                                647                 :                :     /* If we found any generic argument types, cross-check them */
 7677                           648         [ +  + ]:         585069 :     if (have_generics)
                                649                 :                :     {
                                650         [ +  + ]:          60753 :         if (!check_generic_type_consistency(input_typeids, target_typeids,
                                651                 :                :                                             nargs))
                                652                 :          35417 :             return false;
                                653                 :                :     }
                                654                 :                : 
 9472 lockhart@fourpalms.o      655                 :         549652 :     return true;
                                656                 :                : }
                                657                 :                : 
                                658                 :                : 
                                659                 :                : /*
                                660                 :                :  * Create an expression tree to represent coercion to a domain type.
                                661                 :                :  *
                                662                 :                :  * 'arg': input expression
                                663                 :                :  * 'baseTypeId': base type of domain, if known (pass InvalidOid if caller
                                664                 :                :  *      has not bothered to look this up)
                                665                 :                :  * 'baseTypeMod': base type typmod of domain, if known (pass -1 if caller
                                666                 :                :  *      has not bothered to look this up)
                                667                 :                :  * 'typeId': target type to coerce to
                                668                 :                :  * 'ccontext': context indicator to control coercions
                                669                 :                :  * 'cformat': coercion display format
                                670                 :                :  * 'location': coercion request location
                                671                 :                :  * 'hideInputCoercion': if true, hide the input coercion under this one.
                                672                 :                :  *
                                673                 :                :  * If the target type isn't a domain, the given 'arg' is returned as-is.
                                674                 :                :  */
                                675                 :                : Node *
 6584 tgl@sss.pgh.pa.us         676                 :         102898 : coerce_to_domain(Node *arg, Oid baseTypeId, int32 baseTypeMod, Oid typeId,
                                677                 :                :                  CoercionContext ccontext, CoercionForm cformat, int location,
                                678                 :                :                  bool hideInputCoercion)
                                679                 :                : {
                                680                 :                :     CoerceToDomain *result;
                                681                 :                : 
                                682                 :                :     /* Get the base type if it hasn't been supplied */
 7741                           683         [ +  + ]:         102898 :     if (baseTypeId == InvalidOid)
 6584                           684                 :          88437 :         baseTypeId = getBaseTypeAndTypmod(typeId, &baseTypeMod);
                                685                 :                : 
                                686                 :                :     /* If it isn't a domain, return the node as it was passed in */
 7741                           687         [ +  + ]:         102898 :     if (baseTypeId == typeId)
                                688                 :          70119 :         return arg;
                                689                 :                : 
                                690                 :                :     /* Suppress display of nested coercion steps */
 7242                           691         [ +  + ]:          32779 :     if (hideInputCoercion)
                                692                 :           1012 :         hide_coercion_node(arg);
                                693                 :                : 
                                694                 :                :     /*
                                695                 :                :      * If the domain applies a typmod to its base type, build the appropriate
                                696                 :                :      * coercion step.  Mark it implicit for display purposes, because we don't
                                697                 :                :      * want it shown separately by ruleutils.c; but the isExplicit flag passed
                                698                 :                :      * to the conversion function depends on the manner in which the domain
                                699                 :                :      * coercion is invoked, so that the semantics of implicit and explicit
                                700                 :                :      * coercion differ.  (Is that really the behavior we want?)
                                701                 :                :      *
                                702                 :                :      * NOTE: because we apply this as part of the fixed expression structure,
                                703                 :                :      * ALTER DOMAIN cannot alter the typtypmod.  But it's unclear that that
                                704                 :                :      * would be safe to do anyway, without lots of knowledge about what the
                                705                 :                :      * base type thinks the typmod means.
                                706                 :                :      */
 2388                           707                 :          32779 :     arg = coerce_type_typmod(arg, baseTypeId, baseTypeMod,
                                708                 :                :                              ccontext, COERCE_IMPLICIT_CAST, location,
                                709                 :                :                              false);
                                710                 :                : 
                                711                 :                :     /*
                                712                 :                :      * Now build the domain coercion node.  This represents run-time checking
                                713                 :                :      * of any constraints currently attached to the domain.  This also ensures
                                714                 :                :      * that the expression is properly labeled as to result type.
                                715                 :                :      */
 7741                           716                 :          32779 :     result = makeNode(CoerceToDomain);
                                717                 :          32779 :     result->arg = (Expr *) arg;
                                718                 :          32779 :     result->resulttype = typeId;
                                719                 :          32779 :     result->resulttypmod = -1;   /* currently, always -1 for domains */
                                720                 :                :     /* resultcollid will be set by parse_collate.c */
                                721                 :          32779 :     result->coercionformat = cformat;
 5708                           722                 :          32779 :     result->location = location;
                                723                 :                : 
 7741                           724                 :          32779 :     return (Node *) result;
                                725                 :                : }
                                726                 :                : 
                                727                 :                : 
                                728                 :                : /*
                                729                 :                :  * coerce_type_typmod()
                                730                 :                :  *      Force a value to a particular typmod, if meaningful and possible.
                                731                 :                :  *
                                732                 :                :  * This is applied to values that are going to be stored in a relation
                                733                 :                :  * (where we have an atttypmod for the column) as well as values being
                                734                 :                :  * explicitly CASTed (where the typmod comes from the target type spec).
                                735                 :                :  *
                                736                 :                :  * The caller must have already ensured that the value is of the correct
                                737                 :                :  * type, typically by applying coerce_type.
                                738                 :                :  *
                                739                 :                :  * ccontext may affect semantics, depending on whether the length coercion
                                740                 :                :  * function pays attention to the isExplicit flag it's passed.
                                741                 :                :  *
                                742                 :                :  * cformat determines the display properties of the generated node (if any).
                                743                 :                :  *
                                744                 :                :  * If hideInputCoercion is true *and* we generate a node, the input node is
                                745                 :                :  * forced to IMPLICIT display form, so that only the typmod coercion node will
                                746                 :                :  * be visible when displaying the expression.
                                747                 :                :  *
                                748                 :                :  * NOTE: this does not need to work on domain types, because any typmod
                                749                 :                :  * coercion for a domain is considered to be part of the type coercion
                                750                 :                :  * needed to produce the domain value in the first place.  So, no getBaseType.
                                751                 :                :  */
                                752                 :                : static Node *
 7879                           753                 :         384928 : coerce_type_typmod(Node *node, Oid targetTypeId, int32 targetTypMod,
                                754                 :                :                    CoercionContext ccontext, CoercionForm cformat,
                                755                 :                :                    int location,
                                756                 :                :                    bool hideInputCoercion)
                                757                 :                : {
                                758                 :                :     CoercionPathType pathtype;
                                759                 :                :     Oid         funcId;
                                760                 :                : 
                                761                 :                :     /* Skip coercion if already done */
  982                           762         [ +  + ]:         384928 :     if (targetTypMod == exprTypmod(node))
 8854                           763                 :         374880 :         return node;
                                764                 :                : 
                                765                 :                :     /* Suppress display of nested coercion steps */
  982                           766         [ +  + ]:          10048 :     if (hideInputCoercion)
                                767                 :            552 :         hide_coercion_node(node);
                                768                 :                : 
                                769                 :                :     /*
                                770                 :                :      * A negative typmod means that no actual coercion is needed, but we still
                                771                 :                :      * want a RelabelType to ensure that the expression exposes the intended
                                772                 :                :      * typmod.
                                773                 :                :      */
  850                           774         [ +  + ]:          10048 :     if (targetTypMod < 0)
                                775                 :             15 :         pathtype = COERCION_PATH_NONE;
                                776                 :                :     else
                                777                 :          10033 :         pathtype = find_typmod_coercion_function(targetTypeId, &funcId);
                                778                 :                : 
 6158                           779         [ +  + ]:          10048 :     if (pathtype != COERCION_PATH_NONE)
                                780                 :                :     {
                                781                 :          10027 :         node = build_coercion_expression(node, pathtype, funcId,
                                782                 :                :                                          targetTypeId, targetTypMod,
                                783                 :                :                                          ccontext, cformat, location);
                                784                 :                :     }
                                785                 :                :     else
                                786                 :                :     {
                                787                 :                :         /*
                                788                 :                :          * We don't need to perform any actual coercion step, but we should
                                789                 :                :          * apply a RelabelType to ensure that the expression exposes the
                                790                 :                :          * intended typmod.
                                791                 :                :          */
  982                           792                 :             21 :         node = applyRelabelType(node, targetTypeId, targetTypMod,
                                793                 :                :                                 exprCollation(node),
                                794                 :                :                                 cformat, location, false);
                                795                 :                :     }
                                796                 :                : 
 7242                           797                 :          10048 :     return node;
                                798                 :                : }
                                799                 :                : 
                                800                 :                : /*
                                801                 :                :  * Mark a coercion node as IMPLICIT so it will never be displayed by
                                802                 :                :  * ruleutils.c.  We use this when we generate a nest of coercion nodes
                                803                 :                :  * to implement what is logically one conversion; the inner nodes are
                                804                 :                :  * forced to IMPLICIT_CAST format.  This does not change their semantics,
                                805                 :                :  * only display behavior.
                                806                 :                :  *
                                807                 :                :  * It is caller error to call this on something that doesn't have a
                                808                 :                :  * CoercionForm field.
                                809                 :                :  */
                                810                 :                : static void
                                811                 :           1564 : hide_coercion_node(Node *node)
                                812                 :                : {
                                813         [ +  + ]:           1564 :     if (IsA(node, FuncExpr))
                                814                 :            708 :         ((FuncExpr *) node)->funcformat = COERCE_IMPLICIT_CAST;
                                815         [ +  + ]:            856 :     else if (IsA(node, RelabelType))
                                816                 :            162 :         ((RelabelType *) node)->relabelformat = COERCE_IMPLICIT_CAST;
 6158                           817         [ +  + ]:            694 :     else if (IsA(node, CoerceViaIO))
                                818                 :            688 :         ((CoerceViaIO *) node)->coerceformat = COERCE_IMPLICIT_CAST;
 6228                           819         [ +  - ]:              6 :     else if (IsA(node, ArrayCoerceExpr))
                                820                 :              6 :         ((ArrayCoerceExpr *) node)->coerceformat = COERCE_IMPLICIT_CAST;
 7064 tgl@sss.pgh.pa.us         821         [ #  # ]:UBC           0 :     else if (IsA(node, ConvertRowtypeExpr))
                                822                 :              0 :         ((ConvertRowtypeExpr *) node)->convertformat = COERCE_IMPLICIT_CAST;
 7242                           823         [ #  # ]:              0 :     else if (IsA(node, RowExpr))
                                824                 :              0 :         ((RowExpr *) node)->row_format = COERCE_IMPLICIT_CAST;
                                825         [ #  # ]:              0 :     else if (IsA(node, CoerceToDomain))
                                826                 :              0 :         ((CoerceToDomain *) node)->coercionformat = COERCE_IMPLICIT_CAST;
                                827                 :                :     else
                                828         [ #  # ]:              0 :         elog(ERROR, "unsupported node type: %d", (int) nodeTag(node));
 7242 tgl@sss.pgh.pa.us         829                 :CBC        1564 : }
                                830                 :                : 
                                831                 :                : /*
                                832                 :                :  * build_coercion_expression()
                                833                 :                :  *      Construct an expression tree for applying a pg_cast entry.
                                834                 :                :  *
                                835                 :                :  * This is used for both type-coercion and length-coercion operations,
                                836                 :                :  * since there is no difference in terms of the calling convention.
                                837                 :                :  */
                                838                 :                : static Node *
 6228                           839                 :          53025 : build_coercion_expression(Node *node,
                                840                 :                :                           CoercionPathType pathtype,
                                841                 :                :                           Oid funcId,
                                842                 :                :                           Oid targetTypeId, int32 targetTypMod,
                                843                 :                :                           CoercionContext ccontext, CoercionForm cformat,
                                844                 :                :                           int location)
                                845                 :                : {
                                846                 :          53025 :     int         nargs = 0;
                                847                 :                : 
                                848         [ +  + ]:          53025 :     if (OidIsValid(funcId))
                                849                 :                :     {
                                850                 :                :         HeapTuple   tp;
                                851                 :                :         Form_pg_proc procstruct;
                                852                 :                : 
 5173 rhaas@postgresql.org      853                 :          40238 :         tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcId));
 6228 tgl@sss.pgh.pa.us         854         [ -  + ]:          40238 :         if (!HeapTupleIsValid(tp))
 6228 tgl@sss.pgh.pa.us         855         [ #  # ]:UBC           0 :             elog(ERROR, "cache lookup failed for function %u", funcId);
 6228 tgl@sss.pgh.pa.us         856                 :CBC       40238 :         procstruct = (Form_pg_proc) GETSTRUCT(tp);
                                857                 :                : 
                                858                 :                :         /*
                                859                 :                :          * These Asserts essentially check that function is a legal coercion
                                860                 :                :          * function.  We can't make the seemingly obvious tests on prorettype
                                861                 :                :          * and proargtypes[0], even in the COERCION_PATH_FUNC case, because of
                                862                 :                :          * various binary-compatibility cases.
                                863                 :                :          */
                                864                 :                :         /* Assert(targetTypeId == procstruct->prorettype); */
                                865         [ -  + ]:          40238 :         Assert(!procstruct->proretset);
 2235 peter_e@gmx.net           866         [ -  + ]:          40238 :         Assert(procstruct->prokind == PROKIND_FUNCTION);
 6228 tgl@sss.pgh.pa.us         867                 :          40238 :         nargs = procstruct->pronargs;
                                868   [ +  -  -  + ]:          40238 :         Assert(nargs >= 1 && nargs <= 3);
                                869                 :                :         /* Assert(procstruct->proargtypes.values[0] == exprType(node)); */
                                870   [ +  +  -  + ]:          40238 :         Assert(nargs < 2 || procstruct->proargtypes.values[1] == INT4OID);
                                871   [ +  +  -  + ]:          40238 :         Assert(nargs < 3 || procstruct->proargtypes.values[2] == BOOLOID);
                                872                 :                : 
                                873                 :          40238 :         ReleaseSysCache(tp);
                                874                 :                :     }
                                875                 :                : 
 6158                           876         [ +  + ]:          53025 :     if (pathtype == COERCION_PATH_FUNC)
                                877                 :                :     {
                                878                 :                :         /* We build an ordinary FuncExpr with special arguments */
                                879                 :                :         FuncExpr   *fexpr;
                                880                 :                :         List       *args;
                                881                 :                :         Const      *cons;
                                882                 :                : 
 6228                           883         [ -  + ]:          40196 :         Assert(OidIsValid(funcId));
                                884                 :                : 
                                885                 :          40196 :         args = list_make1(node);
                                886                 :                : 
                                887         [ +  + ]:          40196 :         if (nargs >= 2)
                                888                 :                :         {
                                889                 :                :             /* Pass target typmod as an int4 constant */
                                890                 :          10618 :             cons = makeConst(INT4OID,
                                891                 :                :                              -1,
                                892                 :                :                              InvalidOid,
                                893                 :                :                              sizeof(int32),
                                894                 :                :                              Int32GetDatum(targetTypMod),
                                895                 :                :                              false,
                                896                 :                :                              true);
                                897                 :                : 
                                898                 :          10618 :             args = lappend(args, cons);
                                899                 :                :         }
                                900                 :                : 
                                901         [ +  + ]:          40196 :         if (nargs == 3)
                                902                 :                :         {
                                903                 :                :             /* Pass it a boolean isExplicit parameter, too */
                                904                 :           6771 :             cons = makeConst(BOOLOID,
                                905                 :                :                              -1,
                                906                 :                :                              InvalidOid,
                                907                 :                :                              sizeof(bool),
                                908                 :                :                              BoolGetDatum(ccontext == COERCION_EXPLICIT),
                                909                 :                :                              false,
                                910                 :                :                              true);
                                911                 :                : 
                                912                 :           6771 :             args = lappend(args, cons);
                                913                 :                :         }
                                914                 :                : 
 4775                           915                 :          40196 :         fexpr = makeFuncExpr(funcId, targetTypeId, args,
                                916                 :                :                              InvalidOid, InvalidOid, cformat);
 5708                           917                 :          40196 :         fexpr->location = location;
                                918                 :          40196 :         return (Node *) fexpr;
                                919                 :                :     }
 6158                           920         [ +  + ]:          12829 :     else if (pathtype == COERCION_PATH_ARRAYCOERCE)
                                921                 :                :     {
                                922                 :                :         /* We need to build an ArrayCoerceExpr */
                                923                 :           2449 :         ArrayCoerceExpr *acoerce = makeNode(ArrayCoerceExpr);
 2388                           924                 :           2449 :         CaseTestExpr *ctest = makeNode(CaseTestExpr);
                                925                 :                :         Oid         sourceBaseTypeId;
                                926                 :                :         int32       sourceBaseTypeMod;
                                927                 :                :         Oid         targetElementType;
                                928                 :                :         Node       *elemexpr;
                                929                 :                : 
                                930                 :                :         /*
                                931                 :                :          * Look through any domain over the source array type.  Note we don't
                                932                 :                :          * expect that the target type is a domain; it must be a plain array.
                                933                 :                :          * (To get to a domain target type, we'll do coerce_to_domain later.)
                                934                 :                :          */
                                935                 :           2449 :         sourceBaseTypeMod = exprTypmod(node);
                                936                 :           2449 :         sourceBaseTypeId = getBaseTypeAndTypmod(exprType(node),
                                937                 :                :                                                 &sourceBaseTypeMod);
                                938                 :                : 
                                939                 :                :         /*
                                940                 :                :          * Set up a CaseTestExpr representing one element of the source array.
                                941                 :                :          * This is an abuse of CaseTestExpr, but it's OK as long as there
                                942                 :                :          * can't be any CaseExpr or ArrayCoerceExpr within the completed
                                943                 :                :          * elemexpr.
                                944                 :                :          */
                                945                 :           2449 :         ctest->typeId = get_element_type(sourceBaseTypeId);
                                946         [ -  + ]:           2449 :         Assert(OidIsValid(ctest->typeId));
                                947                 :           2449 :         ctest->typeMod = sourceBaseTypeMod;
                                948                 :           2449 :         ctest->collation = InvalidOid;   /* Assume coercions don't care */
                                949                 :                : 
                                950                 :                :         /* And coerce it to the target element type */
                                951                 :           2449 :         targetElementType = get_element_type(targetTypeId);
                                952         [ -  + ]:           2449 :         Assert(OidIsValid(targetElementType));
                                953                 :                : 
                                954                 :           2449 :         elemexpr = coerce_to_target_type(NULL,
                                955                 :                :                                          (Node *) ctest,
                                956                 :                :                                          ctest->typeId,
                                957                 :                :                                          targetElementType,
                                958                 :                :                                          targetTypMod,
                                959                 :                :                                          ccontext,
                                960                 :                :                                          cformat,
                                961                 :                :                                          location);
                                962         [ -  + ]:           2449 :         if (elemexpr == NULL)   /* shouldn't happen */
 2388 tgl@sss.pgh.pa.us         963         [ #  # ]:UBC           0 :             elog(ERROR, "failed to coerce array element type as expected");
                                964                 :                : 
 6158 tgl@sss.pgh.pa.us         965                 :CBC        2449 :         acoerce->arg = (Expr *) node;
 2388                           966                 :           2449 :         acoerce->elemexpr = (Expr *) elemexpr;
 6158                           967                 :           2449 :         acoerce->resulttype = targetTypeId;
                                968                 :                : 
                                969                 :                :         /*
                                970                 :                :          * Label the output as having a particular element typmod only if we
                                971                 :                :          * ended up with a per-element expression that is labeled that way.
                                972                 :                :          */
 2388                           973                 :           2449 :         acoerce->resulttypmod = exprTypmod(elemexpr);
                                974                 :                :         /* resultcollid will be set by parse_collate.c */
 6158                           975                 :           2449 :         acoerce->coerceformat = cformat;
 5708                           976                 :           2449 :         acoerce->location = location;
                                977                 :                : 
 6158                           978                 :           2449 :         return (Node *) acoerce;
                                979                 :                :     }
                                980         [ +  - ]:          10380 :     else if (pathtype == COERCION_PATH_COERCEVIAIO)
                                981                 :                :     {
                                982                 :                :         /* We need to build a CoerceViaIO node */
                                983                 :          10380 :         CoerceViaIO *iocoerce = makeNode(CoerceViaIO);
                                984                 :                : 
                                985         [ -  + ]:          10380 :         Assert(!OidIsValid(funcId));
                                986                 :                : 
                                987                 :          10380 :         iocoerce->arg = (Expr *) node;
                                988                 :          10380 :         iocoerce->resulttype = targetTypeId;
                                989                 :                :         /* resultcollid will be set by parse_collate.c */
                                990                 :          10380 :         iocoerce->coerceformat = cformat;
 5708                           991                 :          10380 :         iocoerce->location = location;
                                992                 :                : 
 6158                           993                 :          10380 :         return (Node *) iocoerce;
                                994                 :                :     }
                                995                 :                :     else
                                996                 :                :     {
 6158 tgl@sss.pgh.pa.us         997         [ #  # ]:UBC           0 :         elog(ERROR, "unsupported pathtype %d in build_coercion_expression",
                                998                 :                :              (int) pathtype);
                                999                 :                :         return NULL;            /* keep compiler quiet */
                               1000                 :                :     }
                               1001                 :                : }
                               1002                 :                : 
                               1003                 :                : 
                               1004                 :                : /*
                               1005                 :                :  * coerce_record_to_complex
                               1006                 :                :  *      Coerce a RECORD to a specific composite type.
                               1007                 :                :  *
                               1008                 :                :  * Currently we only support this for inputs that are RowExprs or whole-row
                               1009                 :                :  * Vars.
                               1010                 :                :  */
                               1011                 :                : static Node *
 7279 tgl@sss.pgh.pa.us        1012                 :CBC         935 : coerce_record_to_complex(ParseState *pstate, Node *node,
                               1013                 :                :                          Oid targetTypeId,
                               1014                 :                :                          CoercionContext ccontext,
                               1015                 :                :                          CoercionForm cformat,
                               1016                 :                :                          int location)
                               1017                 :                : {
                               1018                 :                :     RowExpr    *rowexpr;
                               1019                 :                :     Oid         baseTypeId;
 2362                          1020                 :            935 :     int32       baseTypeMod = -1;
                               1021                 :                :     TupleDesc   tupdesc;
 7279                          1022                 :            935 :     List       *args = NIL;
                               1023                 :                :     List       *newargs;
                               1024                 :                :     int         i;
                               1025                 :                :     int         ucolno;
                               1026                 :                :     ListCell   *arg;
                               1027                 :                : 
                               1028   [ +  -  +  - ]:            935 :     if (node && IsA(node, RowExpr))
                               1029                 :                :     {
                               1030                 :                :         /*
                               1031                 :                :          * Since the RowExpr must be of type RECORD, we needn't worry about it
                               1032                 :                :          * containing any dropped columns.
                               1033                 :                :          */
                               1034                 :            935 :         args = ((RowExpr *) node)->args;
                               1035                 :                :     }
 7279 tgl@sss.pgh.pa.us        1036   [ #  #  #  # ]:UBC           0 :     else if (node && IsA(node, Var) &&
                               1037         [ #  # ]:              0 :              ((Var *) node)->varattno == InvalidAttrNumber)
                               1038                 :              0 :     {
 7168 bruce@momjian.us         1039                 :              0 :         int         rtindex = ((Var *) node)->varno;
                               1040                 :              0 :         int         sublevels_up = ((Var *) node)->varlevelsup;
 5704 tgl@sss.pgh.pa.us        1041                 :              0 :         int         vlocation = ((Var *) node)->location;
                               1042                 :                :         ParseNamespaceItem *nsitem;
                               1043                 :                : 
 1564                          1044                 :              0 :         nsitem = GetNSItemByRangeTablePosn(pstate, rtindex, sublevels_up);
  440                          1045                 :              0 :         args = expandNSItemVars(pstate, nsitem, sublevels_up, vlocation, NULL);
                               1046                 :                :     }
                               1047                 :                :     else
 7279                          1048         [ #  # ]:              0 :         ereport(ERROR,
                               1049                 :                :                 (errcode(ERRCODE_CANNOT_COERCE),
                               1050                 :                :                  errmsg("cannot cast type %s to %s",
                               1051                 :                :                         format_type_be(RECORDOID),
                               1052                 :                :                         format_type_be(targetTypeId)),
                               1053                 :                :                  parser_coercion_errposition(pstate, location, node)));
                               1054                 :                : 
                               1055                 :                :     /*
                               1056                 :                :      * Look up the composite type, accounting for possibility that what we are
                               1057                 :                :      * given is a domain over composite.
                               1058                 :                :      */
 2362 tgl@sss.pgh.pa.us        1059                 :CBC         935 :     baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod);
                               1060                 :            935 :     tupdesc = lookup_rowtype_tupdesc(baseTypeId, baseTypeMod);
                               1061                 :                : 
                               1062                 :                :     /* Process the fields */
 7279                          1063                 :            935 :     newargs = NIL;
 7180                          1064                 :            935 :     ucolno = 1;
                               1065                 :            935 :     arg = list_head(args);
                               1066         [ +  + ]:           3072 :     for (i = 0; i < tupdesc->natts; i++)
                               1067                 :                :     {
                               1068                 :                :         Node       *expr;
                               1069                 :                :         Node       *cexpr;
                               1070                 :                :         Oid         exprtype;
 2429 andres@anarazel.de       1071                 :           2137 :         Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
                               1072                 :                : 
                               1073                 :                :         /* Fill in NULLs for dropped columns in rowtype */
                               1074         [ +  + ]:           2137 :         if (attr->attisdropped)
                               1075                 :                :         {
                               1076                 :                :             /*
                               1077                 :                :              * can't use atttypid here, but it doesn't really matter what type
                               1078                 :                :              * the Const claims to be.
                               1079                 :                :              */
 4769 tgl@sss.pgh.pa.us        1080                 :              3 :             newargs = lappend(newargs,
                               1081                 :              3 :                               makeNullConst(INT4OID, -1, InvalidOid));
 7180                          1082                 :              3 :             continue;
                               1083                 :                :         }
                               1084                 :                : 
                               1085         [ -  + ]:           2134 :         if (arg == NULL)
 7180 tgl@sss.pgh.pa.us        1086         [ #  # ]:UBC           0 :             ereport(ERROR,
                               1087                 :                :                     (errcode(ERRCODE_CANNOT_COERCE),
                               1088                 :                :                      errmsg("cannot cast type %s to %s",
                               1089                 :                :                             format_type_be(RECORDOID),
                               1090                 :                :                             format_type_be(targetTypeId)),
                               1091                 :                :                      errdetail("Input has too few columns."),
                               1092                 :                :                      parser_coercion_errposition(pstate, location, node)));
 7180 tgl@sss.pgh.pa.us        1093                 :CBC        2134 :         expr = (Node *) lfirst(arg);
                               1094                 :           2134 :         exprtype = exprType(expr);
                               1095                 :                : 
 5708                          1096                 :           2134 :         cexpr = coerce_to_target_type(pstate,
                               1097                 :                :                                       expr, exprtype,
                               1098                 :                :                                       attr->atttypid,
                               1099                 :                :                                       attr->atttypmod,
                               1100                 :                :                                       ccontext,
                               1101                 :                :                                       COERCE_IMPLICIT_CAST,
                               1102                 :                :                                       -1);
                               1103         [ -  + ]:           2134 :         if (cexpr == NULL)
 7279 tgl@sss.pgh.pa.us        1104         [ #  # ]:UBC           0 :             ereport(ERROR,
                               1105                 :                :                     (errcode(ERRCODE_CANNOT_COERCE),
                               1106                 :                :                      errmsg("cannot cast type %s to %s",
                               1107                 :                :                             format_type_be(RECORDOID),
                               1108                 :                :                             format_type_be(targetTypeId)),
                               1109                 :                :                      errdetail("Cannot cast type %s to %s in column %d.",
                               1110                 :                :                                format_type_be(exprtype),
                               1111                 :                :                                format_type_be(attr->atttypid),
                               1112                 :                :                                ucolno),
                               1113                 :                :                      parser_coercion_errposition(pstate, location, expr)));
 5708 tgl@sss.pgh.pa.us        1114                 :CBC        2134 :         newargs = lappend(newargs, cexpr);
 7180                          1115                 :           2134 :         ucolno++;
 1735                          1116                 :           2134 :         arg = lnext(args, arg);
                               1117                 :                :     }
 7180                          1118         [ -  + ]:            935 :     if (arg != NULL)
 7180 tgl@sss.pgh.pa.us        1119         [ #  # ]:UBC           0 :         ereport(ERROR,
                               1120                 :                :                 (errcode(ERRCODE_CANNOT_COERCE),
                               1121                 :                :                  errmsg("cannot cast type %s to %s",
                               1122                 :                :                         format_type_be(RECORDOID),
                               1123                 :                :                         format_type_be(targetTypeId)),
                               1124                 :                :                  errdetail("Input has too many columns."),
                               1125                 :                :                  parser_coercion_errposition(pstate, location, node)));
                               1126                 :                : 
 6512 tgl@sss.pgh.pa.us        1127         [ +  - ]:CBC         935 :     ReleaseTupleDesc(tupdesc);
                               1128                 :                : 
 7279                          1129                 :            935 :     rowexpr = makeNode(RowExpr);
                               1130                 :            935 :     rowexpr->args = newargs;
 2362                          1131                 :            935 :     rowexpr->row_typeid = baseTypeId;
 7279                          1132                 :            935 :     rowexpr->row_format = cformat;
 5669                          1133                 :            935 :     rowexpr->colnames = NIL; /* not needed for named target type */
 5708                          1134                 :            935 :     rowexpr->location = location;
                               1135                 :                : 
                               1136                 :                :     /* If target is a domain, apply constraints */
 2362                          1137         [ +  + ]:            935 :     if (baseTypeId != targetTypeId)
                               1138                 :                :     {
                               1139                 :             77 :         rowexpr->row_format = COERCE_IMPLICIT_CAST;
                               1140                 :             77 :         return coerce_to_domain((Node *) rowexpr,
                               1141                 :                :                                 baseTypeId, baseTypeMod,
                               1142                 :                :                                 targetTypeId,
                               1143                 :                :                                 ccontext, cformat, location,
                               1144                 :                :                                 false);
                               1145                 :                :     }
                               1146                 :                : 
 7279                          1147                 :            858 :     return (Node *) rowexpr;
                               1148                 :                : }
                               1149                 :                : 
                               1150                 :                : /*
                               1151                 :                :  * coerce_to_boolean()
                               1152                 :                :  *      Coerce an argument of a construct that requires boolean input
                               1153                 :                :  *      (AND, OR, NOT, etc).  Also check that input is not a set.
                               1154                 :                :  *
                               1155                 :                :  * Returns the possibly-transformed node tree.
                               1156                 :                :  *
                               1157                 :                :  * As with coerce_type, pstate may be NULL if no special unknown-Param
                               1158                 :                :  * processing is wanted.
                               1159                 :                :  */
                               1160                 :                : Node *
 7656                          1161                 :         358236 : coerce_to_boolean(ParseState *pstate, Node *node,
                               1162                 :                :                   const char *constructName)
                               1163                 :                : {
 8008                          1164                 :         358236 :     Oid         inputTypeId = exprType(node);
                               1165                 :                : 
                               1166         [ +  + ]:         358236 :     if (inputTypeId != BOOLOID)
                               1167                 :                :     {
                               1168                 :                :         Node       *newnode;
                               1169                 :                : 
 5708                          1170                 :             36 :         newnode = coerce_to_target_type(pstate, node, inputTypeId,
                               1171                 :                :                                         BOOLOID, -1,
                               1172                 :                :                                         COERCION_ASSIGNMENT,
                               1173                 :                :                                         COERCE_IMPLICIT_CAST,
                               1174                 :                :                                         -1);
                               1175         [ +  + ]:             36 :         if (newnode == NULL)
 7575                          1176         [ +  - ]:              3 :             ereport(ERROR,
                               1177                 :                :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                               1178                 :                :             /* translator: first %s is name of a SQL construct, eg WHERE */
                               1179                 :                :                      errmsg("argument of %s must be type %s, not type %s",
                               1180                 :                :                             constructName, "boolean",
                               1181                 :                :                             format_type_be(inputTypeId)),
                               1182                 :                :                      parser_errposition(pstate, exprLocation(node))));
 5708                          1183                 :             33 :         node = newnode;
                               1184                 :                :     }
                               1185                 :                : 
 8008                          1186         [ -  + ]:         358233 :     if (expression_returns_set(node))
 7575 tgl@sss.pgh.pa.us        1187         [ #  # ]:UBC           0 :         ereport(ERROR,
                               1188                 :                :                 (errcode(ERRCODE_DATATYPE_MISMATCH),
                               1189                 :                :         /* translator: %s is name of a SQL construct, eg WHERE */
                               1190                 :                :                  errmsg("argument of %s must not return a set",
                               1191                 :                :                         constructName),
                               1192                 :                :                  parser_errposition(pstate, exprLocation(node))));
                               1193                 :                : 
 7591 tgl@sss.pgh.pa.us        1194                 :CBC      358233 :     return node;
                               1195                 :                : }
                               1196                 :                : 
                               1197                 :                : /*
                               1198                 :                :  * coerce_to_specific_type_typmod()
                               1199                 :                :  *      Coerce an argument of a construct that requires a specific data type,
                               1200                 :                :  *      with a specific typmod.  Also check that input is not a set.
                               1201                 :                :  *
                               1202                 :                :  * Returns the possibly-transformed node tree.
                               1203                 :                :  *
                               1204                 :                :  * As with coerce_type, pstate may be NULL if no special unknown-Param
                               1205                 :                :  * processing is wanted.
                               1206                 :                :  */
                               1207                 :                : Node *
 2594 alvherre@alvh.no-ip.     1208                 :           7252 : coerce_to_specific_type_typmod(ParseState *pstate, Node *node,
                               1209                 :                :                                Oid targetTypeId, int32 targetTypmod,
                               1210                 :                :                                const char *constructName)
                               1211                 :                : {
 6324 peter_e@gmx.net          1212                 :           7252 :     Oid         inputTypeId = exprType(node);
                               1213                 :                : 
 6321 tgl@sss.pgh.pa.us        1214         [ +  + ]:           7252 :     if (inputTypeId != targetTypeId)
                               1215                 :                :     {
                               1216                 :                :         Node       *newnode;
                               1217                 :                : 
 5708                          1218                 :           5159 :         newnode = coerce_to_target_type(pstate, node, inputTypeId,
                               1219                 :                :                                         targetTypeId, targetTypmod,
                               1220                 :                :                                         COERCION_ASSIGNMENT,
                               1221                 :                :                                         COERCE_IMPLICIT_CAST,
                               1222                 :                :                                         -1);
                               1223         [ +  + ]:           5153 :         if (newnode == NULL)
 6324 peter_e@gmx.net          1224         [ +  - ]:              3 :             ereport(ERROR,
                               1225                 :                :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                               1226                 :                :             /* translator: first %s is name of a SQL construct, eg LIMIT */
                               1227                 :                :                      errmsg("argument of %s must be type %s, not type %s",
                               1228                 :                :                             constructName,
                               1229                 :                :                             format_type_be(targetTypeId),
                               1230                 :                :                             format_type_be(inputTypeId)),
                               1231                 :                :                      parser_errposition(pstate, exprLocation(node))));
 5708 tgl@sss.pgh.pa.us        1232                 :           5150 :         node = newnode;
                               1233                 :                :     }
                               1234                 :                : 
 6324 peter_e@gmx.net          1235         [ -  + ]:           7243 :     if (expression_returns_set(node))
 6324 peter_e@gmx.net          1236         [ #  # ]:UBC           0 :         ereport(ERROR,
                               1237                 :                :                 (errcode(ERRCODE_DATATYPE_MISMATCH),
                               1238                 :                :         /* translator: %s is name of a SQL construct, eg LIMIT */
                               1239                 :                :                  errmsg("argument of %s must not return a set",
                               1240                 :                :                         constructName),
                               1241                 :                :                  parser_errposition(pstate, exprLocation(node))));
                               1242                 :                : 
 6324 peter_e@gmx.net          1243                 :CBC        7243 :     return node;
                               1244                 :                : }
                               1245                 :                : 
                               1246                 :                : /*
                               1247                 :                :  * coerce_to_specific_type()
                               1248                 :                :  *      Coerce an argument of a construct that requires a specific data type.
                               1249                 :                :  *      Also check that input is not a set.
                               1250                 :                :  *
                               1251                 :                :  * Returns the possibly-transformed node tree.
                               1252                 :                :  *
                               1253                 :                :  * As with coerce_type, pstate may be NULL if no special unknown-Param
                               1254                 :                :  * processing is wanted.
                               1255                 :                :  */
                               1256                 :                : Node *
 2594 alvherre@alvh.no-ip.     1257                 :           7224 : coerce_to_specific_type(ParseState *pstate, Node *node,
                               1258                 :                :                         Oid targetTypeId,
                               1259                 :                :                         const char *constructName)
                               1260                 :                : {
                               1261                 :           7224 :     return coerce_to_specific_type_typmod(pstate, node,
                               1262                 :                :                                           targetTypeId, -1,
                               1263                 :                :                                           constructName);
                               1264                 :                : }
                               1265                 :                : 
                               1266                 :                : /*
                               1267                 :                :  * parser_coercion_errposition - report coercion error location, if possible
                               1268                 :                :  *
                               1269                 :                :  * We prefer to point at the coercion request (CAST, ::, etc) if possible;
                               1270                 :                :  * but there may be no such location in the case of an implicit coercion.
                               1271                 :                :  * In that case point at the input expression.
                               1272                 :                :  *
                               1273                 :                :  * XXX possibly this is more generally useful than coercion errors;
                               1274                 :                :  * if so, should rename and place with parser_errposition.
                               1275                 :                :  */
                               1276                 :                : int
 5708 tgl@sss.pgh.pa.us        1277                 :             26 : parser_coercion_errposition(ParseState *pstate,
                               1278                 :                :                             int coerce_location,
                               1279                 :                :                             Node *input_expr)
                               1280                 :                : {
                               1281         [ +  - ]:             26 :     if (coerce_location >= 0)
 1481                          1282                 :             26 :         return parser_errposition(pstate, coerce_location);
                               1283                 :                :     else
 1481 tgl@sss.pgh.pa.us        1284                 :UBC           0 :         return parser_errposition(pstate, exprLocation(input_expr));
                               1285                 :                : }
                               1286                 :                : 
                               1287                 :                : 
                               1288                 :                : /*
                               1289                 :                :  * select_common_type()
                               1290                 :                :  *      Determine the common supertype of a list of input expressions.
                               1291                 :                :  *      This is used for determining the output type of CASE, UNION,
                               1292                 :                :  *      and similar constructs.
                               1293                 :                :  *
                               1294                 :                :  * 'exprs' is a *nonempty* list of expressions.  Note that earlier items
                               1295                 :                :  * in the list will be preferred if there is doubt.
                               1296                 :                :  * 'context' is a phrase to use in the error message if we fail to select
                               1297                 :                :  * a usable type.  Pass NULL to have the routine return InvalidOid
                               1298                 :                :  * rather than throwing an error on failure.
                               1299                 :                :  * 'which_expr': if not NULL, receives a pointer to the particular input
                               1300                 :                :  * expression from which the result type was taken.
                               1301                 :                :  *
                               1302                 :                :  * Caution: "failure" just means that there were inputs of different type
                               1303                 :                :  * categories.  It is not guaranteed that all the inputs are coercible to the
                               1304                 :                :  * selected type; caller must check that (see verify_common_type).
                               1305                 :                :  */
                               1306                 :                : Oid
 5708 tgl@sss.pgh.pa.us        1307                 :CBC       66941 : select_common_type(ParseState *pstate, List *exprs, const char *context,
                               1308                 :                :                    Node **which_expr)
                               1309                 :                : {
                               1310                 :                :     Node       *pexpr;
                               1311                 :                :     Oid         ptype;
                               1312                 :                :     TYPCATEGORY pcategory;
                               1313                 :                :     bool        pispreferred;
                               1314                 :                :     ListCell   *lc;
                               1315                 :                : 
                               1316         [ -  + ]:          66941 :     Assert(exprs != NIL);
                               1317                 :          66941 :     pexpr = (Node *) linitial(exprs);
 1735                          1318                 :          66941 :     lc = list_second_cell(exprs);
 5708                          1319                 :          66941 :     ptype = exprType(pexpr);
                               1320                 :                : 
                               1321                 :                :     /*
                               1322                 :                :      * If all input types are valid and exactly the same, just pick that type.
                               1323                 :                :      * This is the only way that we will resolve the result as being a domain
                               1324                 :                :      * type; otherwise domains are smashed to their base types for comparison.
                               1325                 :                :      */
 5984                          1326         [ +  + ]:          66941 :     if (ptype != UNKNOWNOID)
                               1327                 :                :     {
 1735                          1328   [ +  -  +  +  :         104544 :         for_each_cell(lc, exprs, lc)
                                              +  + ]
                               1329                 :                :         {
 5421 bruce@momjian.us         1330                 :          67952 :             Node       *nexpr = (Node *) lfirst(lc);
                               1331                 :          67952 :             Oid         ntype = exprType(nexpr);
                               1332                 :                : 
 5984 tgl@sss.pgh.pa.us        1333         [ +  + ]:          67952 :             if (ntype != ptype)
                               1334                 :          16938 :                 break;
                               1335                 :                :         }
 5708                          1336         [ +  + ]:          53530 :         if (lc == NULL)         /* got to the end of the list? */
                               1337                 :                :         {
                               1338         [ +  + ]:          36592 :             if (which_expr)
                               1339                 :          16786 :                 *which_expr = pexpr;
 5984                          1340                 :          36592 :             return ptype;
                               1341                 :                :         }
                               1342                 :                :     }
                               1343                 :                : 
                               1344                 :                :     /*
                               1345                 :                :      * Nope, so set up for the full algorithm.  Note that at this point, lc
                               1346                 :                :      * points to the first list item with type different from pexpr's; we need
                               1347                 :                :      * not re-examine any items the previous loop advanced over.
                               1348                 :                :      */
                               1349                 :          30349 :     ptype = getBaseType(ptype);
 5737                          1350                 :          30349 :     get_type_category_preferred(ptype, &pcategory, &pispreferred);
                               1351                 :                : 
 1735                          1352   [ +  -  +  +  :          89022 :     for_each_cell(lc, exprs, lc)
                                              +  + ]
                               1353                 :                :     {
 5708                          1354                 :          58679 :         Node       *nexpr = (Node *) lfirst(lc);
                               1355                 :          58679 :         Oid         ntype = getBaseType(exprType(nexpr));
                               1356                 :                : 
                               1357                 :                :         /* move on to next one if no new information... */
 5984                          1358   [ +  +  +  + ]:          58679 :         if (ntype != UNKNOWNOID && ntype != ptype)
                               1359                 :                :         {
                               1360                 :                :             TYPCATEGORY ncategory;
                               1361                 :                :             bool        nispreferred;
                               1362                 :                : 
 5737                          1363                 :          10943 :             get_type_category_preferred(ntype, &ncategory, &nispreferred);
 5984                          1364         [ +  + ]:          10943 :             if (ptype == UNKNOWNOID)
                               1365                 :                :             {
                               1366                 :                :                 /* so far, only unknowns so take anything... */
 5708                          1367                 :           7582 :                 pexpr = nexpr;
 8592                          1368                 :           7582 :                 ptype = ntype;
 5737                          1369                 :           7582 :                 pcategory = ncategory;
                               1370                 :           7582 :                 pispreferred = nispreferred;
                               1371                 :                :             }
                               1372         [ +  + ]:           3361 :             else if (ncategory != pcategory)
                               1373                 :                :             {
                               1374                 :                :                 /*
                               1375                 :                :                  * both types in different categories? then not much hope...
                               1376                 :                :                  */
 5650                          1377         [ -  + ]:              6 :                 if (context == NULL)
 5650 tgl@sss.pgh.pa.us        1378                 :UBC           0 :                     return InvalidOid;
 7575 tgl@sss.pgh.pa.us        1379         [ +  - ]:CBC           6 :                 ereport(ERROR,
                               1380                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               1381                 :                :                 /*------
                               1382                 :                :                   translator: first %s is name of a SQL construct, eg CASE */
                               1383                 :                :                          errmsg("%s types %s and %s cannot be matched",
                               1384                 :                :                                 context,
                               1385                 :                :                                 format_type_be(ptype),
                               1386                 :                :                                 format_type_be(ntype)),
                               1387                 :                :                          parser_errposition(pstate, exprLocation(nexpr))));
                               1388                 :                :             }
 5737                          1389   [ +  +  +  + ]:           4435 :             else if (!pispreferred &&
 6756 bruce@momjian.us         1390                 :           1080 :                      can_coerce_type(1, &ptype, &ntype, COERCION_IMPLICIT) &&
                               1391         [ +  + ]:            684 :                      !can_coerce_type(1, &ntype, &ptype, COERCION_IMPLICIT))
                               1392                 :                :             {
                               1393                 :                :                 /*
                               1394                 :                :                  * take new type if can coerce to it implicitly but not the
                               1395                 :                :                  * other way; but if we have a preferred type, stay on it.
                               1396                 :                :                  */
 5708 tgl@sss.pgh.pa.us        1397                 :            599 :                 pexpr = nexpr;
 8592                          1398                 :            599 :                 ptype = ntype;
 5737                          1399                 :            599 :                 pcategory = ncategory;
                               1400                 :            599 :                 pispreferred = nispreferred;
                               1401                 :                :             }
                               1402                 :                :         }
                               1403                 :                :     }
                               1404                 :                : 
                               1405                 :                :     /*
                               1406                 :                :      * If all the inputs were UNKNOWN type --- ie, unknown-type literals ---
                               1407                 :                :      * then resolve as type TEXT.  This situation comes up with constructs
                               1408                 :                :      * like SELECT (CASE WHEN foo THEN 'bar' ELSE 'baz' END); SELECT 'foo'
                               1409                 :                :      * UNION SELECT 'bar'; It might seem desirable to leave the construct's
                               1410                 :                :      * output type as UNKNOWN, but that really doesn't work, because we'd
                               1411                 :                :      * probably end up needing a runtime coercion from UNKNOWN to something
                               1412                 :                :      * else, and we usually won't have it.  We need to coerce the unknown
                               1413                 :                :      * literals while they are still literals, so a decision has to be made
                               1414                 :                :      * now.
                               1415                 :                :      */
 8557                          1416         [ +  + ]:          30343 :     if (ptype == UNKNOWNOID)
                               1417                 :           5829 :         ptype = TEXTOID;
                               1418                 :                : 
 5708                          1419         [ +  + ]:          30343 :     if (which_expr)
                               1420                 :           6543 :         *which_expr = pexpr;
 8592                          1421                 :          30343 :     return ptype;
                               1422                 :                : }
                               1423                 :                : 
                               1424                 :                : /*
                               1425                 :                :  * select_common_type_from_oids()
                               1426                 :                :  *      Determine the common supertype of an array of type OIDs.
                               1427                 :                :  *
                               1428                 :                :  * This is the same logic as select_common_type(), but working from
                               1429                 :                :  * an array of type OIDs not a list of expressions.  As in that function,
                               1430                 :                :  * earlier entries in the array have some preference over later ones.
                               1431                 :                :  * On failure, return InvalidOid if noerror is true, else throw an error.
                               1432                 :                :  *
                               1433                 :                :  * Caution: "failure" just means that there were inputs of different type
                               1434                 :                :  * categories.  It is not guaranteed that all the inputs are coercible to the
                               1435                 :                :  * selected type; caller must check that (see verify_common_type_from_oids).
                               1436                 :                :  *
                               1437                 :                :  * Note: neither caller will pass any UNKNOWNOID entries, so the tests
                               1438                 :                :  * for that in this function are dead code.  However, they don't cost much,
                               1439                 :                :  * and it seems better to keep this logic as close to select_common_type()
                               1440                 :                :  * as possible.
                               1441                 :                :  */
                               1442                 :                : static Oid
 1487                          1443                 :           3442 : select_common_type_from_oids(int nargs, const Oid *typeids, bool noerror)
                               1444                 :                : {
                               1445                 :                :     Oid         ptype;
                               1446                 :                :     TYPCATEGORY pcategory;
                               1447                 :                :     bool        pispreferred;
                               1448                 :           3442 :     int         i = 1;
                               1449                 :                : 
                               1450         [ -  + ]:           3442 :     Assert(nargs > 0);
                               1451                 :           3442 :     ptype = typeids[0];
                               1452                 :                : 
                               1453                 :                :     /* If all input types are valid and exactly the same, pick that type. */
                               1454         [ +  - ]:           3442 :     if (ptype != UNKNOWNOID)
                               1455                 :                :     {
                               1456         [ +  + ]:           5094 :         for (; i < nargs; i++)
                               1457                 :                :         {
                               1458         [ +  + ]:           2187 :             if (typeids[i] != ptype)
                               1459                 :            535 :                 break;
                               1460                 :                :         }
                               1461         [ +  + ]:           3442 :         if (i == nargs)
                               1462                 :           2907 :             return ptype;
                               1463                 :                :     }
                               1464                 :                : 
                               1465                 :                :     /*
                               1466                 :                :      * Nope, so set up for the full algorithm.  Note that at this point, we
                               1467                 :                :      * can skip array entries before "i"; they are all equal to ptype.
                               1468                 :                :      */
                               1469                 :            535 :     ptype = getBaseType(ptype);
                               1470                 :            535 :     get_type_category_preferred(ptype, &pcategory, &pispreferred);
                               1471                 :                : 
                               1472         [ +  + ]:            787 :     for (; i < nargs; i++)
                               1473                 :                :     {
                               1474                 :            562 :         Oid         ntype = getBaseType(typeids[i]);
                               1475                 :                : 
                               1476                 :                :         /* move on to next one if no new information... */
                               1477   [ +  -  +  + ]:            562 :         if (ntype != UNKNOWNOID && ntype != ptype)
                               1478                 :                :         {
                               1479                 :                :             TYPCATEGORY ncategory;
                               1480                 :                :             bool        nispreferred;
                               1481                 :                : 
                               1482                 :            556 :             get_type_category_preferred(ntype, &ncategory, &nispreferred);
                               1483         [ -  + ]:            556 :             if (ptype == UNKNOWNOID)
                               1484                 :                :             {
                               1485                 :                :                 /* so far, only unknowns so take anything... */
 1487 tgl@sss.pgh.pa.us        1486                 :UBC           0 :                 ptype = ntype;
                               1487                 :              0 :                 pcategory = ncategory;
                               1488                 :              0 :                 pispreferred = nispreferred;
                               1489                 :                :             }
 1487 tgl@sss.pgh.pa.us        1490         [ +  + ]:CBC         556 :             else if (ncategory != pcategory)
                               1491                 :                :             {
                               1492                 :                :                 /*
                               1493                 :                :                  * both types in different categories? then not much hope...
                               1494                 :                :                  */
                               1495         [ +  - ]:            310 :                 if (noerror)
                               1496                 :            310 :                     return InvalidOid;
 1487 tgl@sss.pgh.pa.us        1497         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               1498                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               1499                 :                :                          errmsg("argument types %s and %s cannot be matched",
                               1500                 :                :                                 format_type_be(ptype),
                               1501                 :                :                                 format_type_be(ntype))));
                               1502                 :                :             }
 1487 tgl@sss.pgh.pa.us        1503   [ +  +  +  + ]:CBC         456 :             else if (!pispreferred &&
                               1504                 :            210 :                      can_coerce_type(1, &ptype, &ntype, COERCION_IMPLICIT) &&
                               1505         [ +  - ]:            135 :                      !can_coerce_type(1, &ntype, &ptype, COERCION_IMPLICIT))
                               1506                 :                :             {
                               1507                 :                :                 /*
                               1508                 :                :                  * take new type if can coerce to it implicitly but not the
                               1509                 :                :                  * other way; but if we have a preferred type, stay on it.
                               1510                 :                :                  */
                               1511                 :            135 :                 ptype = ntype;
                               1512                 :            135 :                 pcategory = ncategory;
                               1513                 :            135 :                 pispreferred = nispreferred;
                               1514                 :                :             }
                               1515                 :                :         }
                               1516                 :                :     }
                               1517                 :                : 
                               1518                 :                :     /* Like select_common_type(), choose TEXT if all inputs were UNKNOWN */
                               1519         [ -  + ]:            225 :     if (ptype == UNKNOWNOID)
 1487 tgl@sss.pgh.pa.us        1520                 :UBC           0 :         ptype = TEXTOID;
                               1521                 :                : 
 1487 tgl@sss.pgh.pa.us        1522                 :CBC         225 :     return ptype;
                               1523                 :                : }
                               1524                 :                : 
                               1525                 :                : /*
                               1526                 :                :  * coerce_to_common_type()
                               1527                 :                :  *      Coerce an expression to the given type.
                               1528                 :                :  *
                               1529                 :                :  * This is used following select_common_type() to coerce the individual
                               1530                 :                :  * expressions to the desired type.  'context' is a phrase to use in the
                               1531                 :                :  * error message if we fail to coerce.
                               1532                 :                :  *
                               1533                 :                :  * As with coerce_type, pstate may be NULL if no special unknown-Param
                               1534                 :                :  * processing is wanted.
                               1535                 :                :  */
                               1536                 :                : Node *
 7656                          1537                 :         168107 : coerce_to_common_type(ParseState *pstate, Node *node,
                               1538                 :                :                       Oid targetTypeId, const char *context)
                               1539                 :                : {
 8592                          1540                 :         168107 :     Oid         inputTypeId = exprType(node);
                               1541                 :                : 
                               1542         [ +  + ]:         168107 :     if (inputTypeId == targetTypeId)
                               1543                 :         107155 :         return node;            /* no work */
 7879                          1544         [ +  - ]:          60952 :     if (can_coerce_type(1, &inputTypeId, &targetTypeId, COERCION_IMPLICIT))
 7242                          1545                 :          60952 :         node = coerce_type(pstate, node, inputTypeId, targetTypeId, -1,
                               1546                 :                :                            COERCION_IMPLICIT, COERCE_IMPLICIT_CAST, -1);
                               1547                 :                :     else
 7575 tgl@sss.pgh.pa.us        1548         [ #  # ]:UBC           0 :         ereport(ERROR,
                               1549                 :                :                 (errcode(ERRCODE_CANNOT_COERCE),
                               1550                 :                :         /* translator: first %s is name of a SQL construct, eg CASE */
                               1551                 :                :                  errmsg("%s could not convert type %s to %s",
                               1552                 :                :                         context,
                               1553                 :                :                         format_type_be(inputTypeId),
                               1554                 :                :                         format_type_be(targetTypeId)),
                               1555                 :                :                  parser_errposition(pstate, exprLocation(node))));
 8592 tgl@sss.pgh.pa.us        1556                 :CBC       60949 :     return node;
                               1557                 :                : }
                               1558                 :                : 
                               1559                 :                : /*
                               1560                 :                :  * verify_common_type()
                               1561                 :                :  *      Verify that all input types can be coerced to a proposed common type.
                               1562                 :                :  *      Return true if so, false if not all coercions are possible.
                               1563                 :                :  *
                               1564                 :                :  * Most callers of select_common_type() don't need to do this explicitly
                               1565                 :                :  * because the checks will happen while trying to convert input expressions
                               1566                 :                :  * to the right type, e.g. in coerce_to_common_type().  However, if a separate
                               1567                 :                :  * check step is needed to validate the applicability of the common type, call
                               1568                 :                :  * this.
                               1569                 :                :  */
                               1570                 :                : bool
  806                          1571                 :           7357 : verify_common_type(Oid common_type, List *exprs)
                               1572                 :                : {
                               1573                 :                :     ListCell   *lc;
                               1574                 :                : 
                               1575   [ +  -  +  +  :          36964 :     foreach(lc, exprs)
                                              +  + ]
                               1576                 :                :     {
                               1577                 :          29610 :         Node       *nexpr = (Node *) lfirst(lc);
                               1578                 :          29610 :         Oid         ntype = exprType(nexpr);
                               1579                 :                : 
                               1580         [ +  + ]:          29610 :         if (!can_coerce_type(1, &ntype, &common_type, COERCION_IMPLICIT))
                               1581                 :              3 :             return false;
                               1582                 :                :     }
                               1583                 :           7354 :     return true;
                               1584                 :                : }
                               1585                 :                : 
                               1586                 :                : /*
                               1587                 :                :  * verify_common_type_from_oids()
                               1588                 :                :  *      As above, but work from an array of type OIDs.
                               1589                 :                :  */
                               1590                 :                : static bool
                               1591                 :           3132 : verify_common_type_from_oids(Oid common_type, int nargs, const Oid *typeids)
                               1592                 :                : {
                               1593         [ +  + ]:           8162 :     for (int i = 0; i < nargs; i++)
                               1594                 :                :     {
                               1595         [ +  + ]:           5036 :         if (!can_coerce_type(1, &typeids[i], &common_type, COERCION_IMPLICIT))
                               1596                 :              6 :             return false;
                               1597                 :                :     }
                               1598                 :           3126 :     return true;
                               1599                 :                : }
                               1600                 :                : 
                               1601                 :                : /*
                               1602                 :                :  * select_common_typmod()
                               1603                 :                :  *      Determine the common typmod of a list of input expressions.
                               1604                 :                :  *
                               1605                 :                :  * common_type is the selected common type of the expressions, typically
                               1606                 :                :  * computed using select_common_type().
                               1607                 :                :  */
                               1608                 :                : int32
 1265 peter@eisentraut.org     1609                 :          28250 : select_common_typmod(ParseState *pstate, List *exprs, Oid common_type)
                               1610                 :                : {
                               1611                 :                :     ListCell   *lc;
                               1612                 :          28250 :     bool        first = true;
                               1613                 :          28250 :     int32       result = -1;
                               1614                 :                : 
                               1615   [ +  -  +  +  :          91048 :     foreach(lc, exprs)
                                              +  + ]
                               1616                 :                :     {
 1196 tgl@sss.pgh.pa.us        1617                 :          62909 :         Node       *expr = (Node *) lfirst(lc);
                               1618                 :                : 
                               1619                 :                :         /* Types must match */
 1265 peter@eisentraut.org     1620         [ +  + ]:          62909 :         if (exprType(expr) != common_type)
                               1621                 :            111 :             return -1;
                               1622         [ +  + ]:          62819 :         else if (first)
                               1623                 :                :         {
                               1624                 :          28205 :             result = exprTypmod(expr);
                               1625                 :          28205 :             first = false;
                               1626                 :                :         }
                               1627                 :                :         else
                               1628                 :                :         {
                               1629                 :                :             /* As soon as we see a non-matching typmod, fall back to -1 */
                               1630         [ +  + ]:          34614 :             if (result != exprTypmod(expr))
                               1631                 :             21 :                 return -1;
                               1632                 :                :         }
                               1633                 :                :     }
                               1634                 :                : 
                               1635                 :          28139 :     return result;
                               1636                 :                : }
                               1637                 :                : 
                               1638                 :                : /*
                               1639                 :                :  * check_generic_type_consistency()
                               1640                 :                :  *      Are the actual arguments potentially compatible with a
                               1641                 :                :  *      polymorphic function?
                               1642                 :                :  *
                               1643                 :                :  * The argument consistency rules are:
                               1644                 :                :  *
                               1645                 :                :  * 1) All arguments declared ANYELEMENT must have the same datatype.
                               1646                 :                :  * 2) All arguments declared ANYARRAY must have the same datatype,
                               1647                 :                :  *    which must be a varlena array type.
                               1648                 :                :  * 3) All arguments declared ANYRANGE must be the same range type.
                               1649                 :                :  *    Similarly, all arguments declared ANYMULTIRANGE must be the same
                               1650                 :                :  *    multirange type; and if both of these appear, the ANYRANGE type
                               1651                 :                :  *    must be the element type of the ANYMULTIRANGE type.
                               1652                 :                :  * 4) If there are arguments of more than one of these polymorphic types,
                               1653                 :                :  *    the array element type and/or range subtype must be the same as each
                               1654                 :                :  *    other and the same as the ANYELEMENT type.
                               1655                 :                :  * 5) ANYENUM is treated the same as ANYELEMENT except that if it is used
                               1656                 :                :  *    (alone or in combination with plain ANYELEMENT), we add the extra
                               1657                 :                :  *    condition that the ANYELEMENT type must be an enum.
                               1658                 :                :  * 6) ANYNONARRAY is treated the same as ANYELEMENT except that if it is used,
                               1659                 :                :  *    we add the extra condition that the ANYELEMENT type must not be an array.
                               1660                 :                :  *    (This is a no-op if used in combination with ANYARRAY or ANYENUM, but
                               1661                 :                :  *    is an extra restriction if not.)
                               1662                 :                :  * 7) All arguments declared ANYCOMPATIBLE must be implicitly castable
                               1663                 :                :  *    to a common supertype (chosen as per select_common_type's rules).
                               1664                 :                :  *    ANYCOMPATIBLENONARRAY works like ANYCOMPATIBLE but also requires the
                               1665                 :                :  *    common supertype to not be an array.  If there are ANYCOMPATIBLEARRAY
                               1666                 :                :  *    or ANYCOMPATIBLERANGE or ANYCOMPATIBLEMULTIRANGE arguments, their element
                               1667                 :                :  *    types or subtypes are included while making the choice of common supertype.
                               1668                 :                :  * 8) The resolved type of ANYCOMPATIBLEARRAY arguments will be the array
                               1669                 :                :  *    type over the common supertype (which might not be the same array type
                               1670                 :                :  *    as any of the original arrays).
                               1671                 :                :  * 9) All ANYCOMPATIBLERANGE arguments must be the exact same range type
                               1672                 :                :  *    (after domain flattening), since we have no preference rule that would
                               1673                 :                :  *    let us choose one over another.  Furthermore, that range's subtype
                               1674                 :                :  *    must exactly match the common supertype chosen by rule 7.
                               1675                 :                :  * 10) All ANYCOMPATIBLEMULTIRANGE arguments must be the exact same multirange
                               1676                 :                :  *    type (after domain flattening), since we have no preference rule that
                               1677                 :                :  *    would let us choose one over another.  Furthermore, if ANYCOMPATIBLERANGE
                               1678                 :                :  *    also appears, that range type must be the multirange's element type;
                               1679                 :                :  *    otherwise, the multirange's range's subtype must exactly match the
                               1680                 :                :  *    common supertype chosen by rule 7.
                               1681                 :                :  *
                               1682                 :                :  * Domains over arrays match ANYARRAY, and are immediately flattened to their
                               1683                 :                :  * base type.  (Thus, for example, we will consider it a match if one ANYARRAY
                               1684                 :                :  * argument is a domain over int4[] while another one is just int4[].)  Also
                               1685                 :                :  * notice that such a domain does *not* match ANYNONARRAY.  The same goes
                               1686                 :                :  * for ANYCOMPATIBLEARRAY and ANYCOMPATIBLENONARRAY.
                               1687                 :                :  *
                               1688                 :                :  * Similarly, domains over ranges match ANYRANGE or ANYCOMPATIBLERANGE,
                               1689                 :                :  * and are immediately flattened to their base type.  Likewise, domains
                               1690                 :                :  * over multiranges match ANYMULTIRANGE or ANYCOMPATIBLEMULTIRANGE and are
                               1691                 :                :  * immediately flattened to their base type.
                               1692                 :                :  *
                               1693                 :                :  * Note that domains aren't currently considered to match ANYENUM,
                               1694                 :                :  * even if their base type would match.
                               1695                 :                :  *
                               1696                 :                :  * If we have UNKNOWN input (ie, an untyped literal) for any polymorphic
                               1697                 :                :  * argument, assume it is okay.
                               1698                 :                :  *
                               1699                 :                :  * We do not ereport here, but just return false if a rule is violated.
                               1700                 :                :  */
                               1701                 :                : bool
 2000 peter_e@gmx.net          1702                 :          60753 : check_generic_type_consistency(const Oid *actual_arg_types,
                               1703                 :                :                                const Oid *declared_arg_types,
                               1704                 :                :                                int nargs)
                               1705                 :                : {
 7677 tgl@sss.pgh.pa.us        1706                 :          60753 :     Oid         elem_typeid = InvalidOid;
                               1707                 :          60753 :     Oid         array_typeid = InvalidOid;
 4546 heikki.linnakangas@i     1708                 :          60753 :     Oid         range_typeid = InvalidOid;
 1211 akorotkov@postgresql     1709                 :          60753 :     Oid         multirange_typeid = InvalidOid;
 1487 tgl@sss.pgh.pa.us        1710                 :          60753 :     Oid         anycompatible_range_typeid = InvalidOid;
                               1711                 :          60753 :     Oid         anycompatible_range_typelem = InvalidOid;
 1211 akorotkov@postgresql     1712                 :          60753 :     Oid         anycompatible_multirange_typeid = InvalidOid;
                               1713                 :          60753 :     Oid         anycompatible_multirange_typelem = InvalidOid;
                               1714                 :          60753 :     Oid         range_typelem = InvalidOid;
 6157 tgl@sss.pgh.pa.us        1715                 :          60753 :     bool        have_anynonarray = false;
 6222                          1716                 :          60753 :     bool        have_anyenum = false;
 1487                          1717                 :          60753 :     bool        have_anycompatible_nonarray = false;
                               1718                 :          60753 :     int         n_anycompatible_args = 0;
                               1719                 :                :     Oid         anycompatible_actual_types[FUNC_MAX_ARGS];
                               1720                 :                : 
                               1721                 :                :     /*
                               1722                 :                :      * Loop through the arguments to see if we have any that are polymorphic.
                               1723                 :                :      * If so, require the actual types to be consistent.
                               1724                 :                :      */
                               1725         [ -  + ]:          60753 :     Assert(nargs <= FUNC_MAX_ARGS);
 1489                          1726         [ +  + ]:         141581 :     for (int j = 0; j < nargs; j++)
                               1727                 :                :     {
 6157                          1728                 :          97082 :         Oid         decl_type = declared_arg_types[j];
 7559 bruce@momjian.us         1729                 :          97082 :         Oid         actual_type = actual_arg_types[j];
                               1730                 :                : 
 6157 tgl@sss.pgh.pa.us        1731   [ +  +  +  + ]:          97082 :         if (decl_type == ANYELEMENTOID ||
                               1732         [ +  + ]:          85742 :             decl_type == ANYNONARRAYOID ||
                               1733                 :                :             decl_type == ANYENUMOID)
                               1734                 :                :         {
                               1735         [ +  + ]:          21758 :             if (decl_type == ANYNONARRAYOID)
                               1736                 :           8135 :                 have_anynonarray = true;
                               1737         [ +  + ]:          13623 :             else if (decl_type == ANYENUMOID)
 6222                          1738                 :          10418 :                 have_anyenum = true;
 7677                          1739         [ +  + ]:          21758 :             if (actual_type == UNKNOWNOID)
                               1740                 :           1182 :                 continue;
                               1741   [ +  +  +  + ]:          20576 :             if (OidIsValid(elem_typeid) && actual_type != elem_typeid)
                               1742                 :           3645 :                 return false;
                               1743                 :          16931 :             elem_typeid = actual_type;
                               1744                 :                :         }
 6157                          1745         [ +  + ]:          75324 :         else if (decl_type == ANYARRAYOID)
                               1746                 :                :         {
 7677                          1747         [ +  + ]:          28707 :             if (actual_type == UNKNOWNOID)
                               1748                 :           1294 :                 continue;
 2489                          1749                 :          27413 :             actual_type = getBaseType(actual_type); /* flatten domains */
 7677                          1750   [ +  +  +  + ]:          27413 :             if (OidIsValid(array_typeid) && actual_type != array_typeid)
                               1751                 :           3638 :                 return false;
                               1752                 :          23775 :             array_typeid = actual_type;
                               1753                 :                :         }
 4546 heikki.linnakangas@i     1754         [ +  + ]:          46617 :         else if (decl_type == ANYRANGEOID)
                               1755                 :                :         {
                               1756         [ +  + ]:          15930 :             if (actual_type == UNKNOWNOID)
                               1757                 :            951 :                 continue;
 2489 tgl@sss.pgh.pa.us        1758                 :          14979 :             actual_type = getBaseType(actual_type); /* flatten domains */
 4546 heikki.linnakangas@i     1759   [ +  +  +  + ]:          14979 :             if (OidIsValid(range_typeid) && actual_type != range_typeid)
                               1760                 :           4044 :                 return false;
                               1761                 :          10935 :             range_typeid = actual_type;
                               1762                 :                :         }
 1211 akorotkov@postgresql     1763         [ +  + ]:          30687 :         else if (decl_type == ANYMULTIRANGEOID)
                               1764                 :                :         {
                               1765         [ +  + ]:          17736 :             if (actual_type == UNKNOWNOID)
                               1766                 :            960 :                 continue;
                               1767                 :          16776 :             actual_type = getBaseType(actual_type); /* flatten domains */
                               1768   [ +  +  +  + ]:          16776 :             if (OidIsValid(multirange_typeid) && actual_type != multirange_typeid)
                               1769                 :           4041 :                 return false;
                               1770                 :          12735 :             multirange_typeid = actual_type;
                               1771                 :                :         }
 1487 tgl@sss.pgh.pa.us        1772   [ +  +  +  + ]:          12951 :         else if (decl_type == ANYCOMPATIBLEOID ||
                               1773                 :                :                  decl_type == ANYCOMPATIBLENONARRAYOID)
                               1774                 :                :         {
                               1775         [ +  + ]:           1921 :             if (decl_type == ANYCOMPATIBLENONARRAYOID)
                               1776                 :             18 :                 have_anycompatible_nonarray = true;
                               1777         [ +  + ]:           1921 :             if (actual_type == UNKNOWNOID)
                               1778                 :            676 :                 continue;
                               1779                 :                :             /* collect the actual types of non-unknown COMPATIBLE args */
                               1780                 :           1245 :             anycompatible_actual_types[n_anycompatible_args++] = actual_type;
                               1781                 :                :         }
                               1782         [ +  + ]:          11030 :         else if (decl_type == ANYCOMPATIBLEARRAYOID)
                               1783                 :                :         {
                               1784                 :                :             Oid         elem_type;
                               1785                 :                : 
                               1786         [ +  + ]:           2763 :             if (actual_type == UNKNOWNOID)
                               1787                 :            448 :                 continue;
                               1788                 :           2315 :             actual_type = getBaseType(actual_type); /* flatten domains */
                               1789                 :           2315 :             elem_type = get_element_type(actual_type);
                               1790         [ +  + ]:           2315 :             if (!OidIsValid(elem_type))
                               1791                 :            874 :                 return false;   /* not an array */
                               1792                 :                :             /* collect the element type for common-supertype choice */
                               1793                 :           1441 :             anycompatible_actual_types[n_anycompatible_args++] = elem_type;
                               1794                 :                :         }
                               1795         [ +  + ]:           8267 :         else if (decl_type == ANYCOMPATIBLERANGEOID)
                               1796                 :                :         {
                               1797         [ +  + ]:             93 :             if (actual_type == UNKNOWNOID)
                               1798                 :              6 :                 continue;
                               1799                 :             87 :             actual_type = getBaseType(actual_type); /* flatten domains */
                               1800         [ +  + ]:             87 :             if (OidIsValid(anycompatible_range_typeid))
                               1801                 :                :             {
                               1802                 :                :                 /* All ANYCOMPATIBLERANGE arguments must be the same type */
                               1803         [ +  + ]:              6 :                 if (anycompatible_range_typeid != actual_type)
                               1804                 :              3 :                     return false;
                               1805                 :                :             }
                               1806                 :                :             else
                               1807                 :                :             {
                               1808                 :             81 :                 anycompatible_range_typeid = actual_type;
                               1809                 :             81 :                 anycompatible_range_typelem = get_range_subtype(actual_type);
                               1810         [ +  + ]:             81 :                 if (!OidIsValid(anycompatible_range_typelem))
                               1811                 :              3 :                     return false;   /* not a range type */
                               1812                 :                :                 /* collect the subtype for common-supertype choice */
                               1813                 :             78 :                 anycompatible_actual_types[n_anycompatible_args++] = anycompatible_range_typelem;
                               1814                 :                :             }
                               1815                 :                :         }
 1211 akorotkov@postgresql     1816         [ +  + ]:           8174 :         else if (decl_type == ANYCOMPATIBLEMULTIRANGEOID)
                               1817                 :                :         {
                               1818         [ +  + ]:             69 :             if (actual_type == UNKNOWNOID)
                               1819                 :              9 :                 continue;
                               1820                 :             60 :             actual_type = getBaseType(actual_type); /* flatten domains */
                               1821         [ +  + ]:             60 :             if (OidIsValid(anycompatible_multirange_typeid))
                               1822                 :                :             {
                               1823                 :                :                 /* All ANYCOMPATIBLEMULTIRANGE arguments must be the same type */
                               1824         [ +  + ]:              6 :                 if (anycompatible_multirange_typeid != actual_type)
                               1825                 :              3 :                     return false;
                               1826                 :                :             }
                               1827                 :                :             else
                               1828                 :                :             {
                               1829                 :             54 :                 anycompatible_multirange_typeid = actual_type;
                               1830                 :             54 :                 anycompatible_multirange_typelem = get_multirange_range(actual_type);
                               1831         [ +  + ]:             54 :                 if (!OidIsValid(anycompatible_multirange_typelem))
                               1832                 :              3 :                     return false;   /* not a multirange type */
                               1833                 :                :                 /* we'll consider the subtype below */
                               1834                 :                :             }
                               1835                 :                :         }
                               1836                 :                :     }
                               1837                 :                : 
                               1838                 :                :     /* Get the element type based on the array type, if we have one */
 7677 tgl@sss.pgh.pa.us        1839         [ +  + ]:          44499 :     if (OidIsValid(array_typeid))
                               1840                 :                :     {
 7509                          1841         [ +  - ]:          18950 :         if (array_typeid == ANYARRAYOID)
                               1842                 :                :         {
                               1843                 :                :             /*
                               1844                 :                :              * Special case for matching ANYARRAY input to an ANYARRAY
                               1845                 :                :              * argument: allow it for now.  enforce_generic_type_consistency()
                               1846                 :                :              * might complain later, depending on the presence of other
                               1847                 :                :              * polymorphic arguments or results, but it will deliver a less
                               1848                 :                :              * surprising error message than "function does not exist".
                               1849                 :                :              *
                               1850                 :                :              * (If you think to change this, note that can_coerce_type will
                               1851                 :                :              * consider such a situation as a match, so that we might not even
                               1852                 :                :              * get here.)
                               1853                 :                :              */
                               1854                 :                :         }
                               1855                 :                :         else
                               1856                 :                :         {
                               1857                 :                :             Oid         array_typelem;
                               1858                 :                : 
 1489                          1859                 :          18950 :             array_typelem = get_element_type(array_typeid);
                               1860         [ +  + ]:          18950 :             if (!OidIsValid(array_typelem))
                               1861                 :           8048 :                 return false;   /* should be an array, but isn't */
                               1862                 :                : 
                               1863         [ +  + ]:          10902 :             if (!OidIsValid(elem_typeid))
                               1864                 :                :             {
                               1865                 :                :                 /*
                               1866                 :                :                  * if we don't have an element type yet, use the one we just
                               1867                 :                :                  * got
                               1868                 :                :                  */
                               1869                 :          10838 :                 elem_typeid = array_typelem;
                               1870                 :                :             }
                               1871         [ +  + ]:             64 :             else if (array_typelem != elem_typeid)
                               1872                 :                :             {
                               1873                 :                :                 /* otherwise, they better match */
                               1874                 :             24 :                 return false;
                               1875                 :                :             }
                               1876                 :                :         }
                               1877                 :                :     }
                               1878                 :                : 
                               1879                 :                :     /* Deduce range type from multirange type, or check that they agree */
 1211 akorotkov@postgresql     1880         [ +  + ]:          36427 :     if (OidIsValid(multirange_typeid))
                               1881                 :                :     {
                               1882                 :                :         Oid         multirange_typelem;
                               1883                 :                : 
                               1884                 :           7361 :         multirange_typelem = get_multirange_range(multirange_typeid);
                               1885         [ +  + ]:           7361 :         if (!OidIsValid(multirange_typelem))
                               1886                 :           6379 :             return false;       /* should be a multirange, but isn't */
                               1887                 :                : 
                               1888         [ +  + ]:            982 :         if (!OidIsValid(range_typeid))
                               1889                 :                :         {
                               1890                 :                :             /* If we don't have a range type yet, use the one we just got */
                               1891                 :            723 :             range_typeid = multirange_typelem;
                               1892                 :            723 :             range_typelem = get_range_subtype(multirange_typelem);
                               1893         [ -  + ]:            723 :             if (!OidIsValid(range_typelem))
 1211 akorotkov@postgresql     1894                 :UBC           0 :                 return false;   /* should be a range, but isn't */
                               1895                 :                :         }
 1211 akorotkov@postgresql     1896         [ +  + ]:CBC         259 :         else if (multirange_typelem != range_typeid)
                               1897                 :                :         {
                               1898                 :                :             /* otherwise, they better match */
                               1899                 :            147 :             return false;
                               1900                 :                :         }
                               1901                 :                :     }
                               1902                 :                : 
                               1903                 :                :     /* Get the element type based on the range type, if we have one */
  992 tgl@sss.pgh.pa.us        1904         [ +  + ]:          29901 :     if (OidIsValid(range_typeid))
                               1905                 :                :     {
                               1906                 :           4965 :         range_typelem = get_range_subtype(range_typeid);
                               1907         [ +  + ]:           4965 :         if (!OidIsValid(range_typelem))
                               1908                 :           2543 :             return false;       /* should be a range, but isn't */
                               1909                 :                : 
 1211 akorotkov@postgresql     1910         [ +  + ]:           2422 :         if (!OidIsValid(elem_typeid))
                               1911                 :                :         {
                               1912                 :                :             /*
                               1913                 :                :              * If we don't have an element type yet, use the one we just got
                               1914                 :                :              */
                               1915                 :           2232 :             elem_typeid = range_typelem;
                               1916                 :                :         }
                               1917         [ +  + ]:            190 :         else if (range_typelem != elem_typeid)
                               1918                 :                :         {
                               1919                 :                :             /* otherwise, they better match */
                               1920                 :             88 :             return false;
                               1921                 :                :         }
                               1922                 :                :     }
                               1923                 :                : 
 4529 tgl@sss.pgh.pa.us        1924         [ +  + ]:          27270 :     if (have_anynonarray)
                               1925                 :                :     {
                               1926                 :                :         /* require the element type to not be an array or domain over array */
                               1927         [ +  + ]:           7959 :         if (type_is_array_domain(elem_typeid))
                               1928                 :            115 :             return false;
                               1929                 :                :     }
                               1930                 :                : 
                               1931         [ +  + ]:          27155 :     if (have_anyenum)
                               1932                 :                :     {
                               1933                 :                :         /* require the element type to be an enum */
                               1934         [ +  + ]:           1671 :         if (!type_is_enum(elem_typeid))
                               1935                 :           1476 :             return false;
                               1936                 :                :     }
                               1937                 :                : 
                               1938                 :                :     /* Deduce range type from multirange type, or check that they agree */
  992                          1939         [ +  + ]:          25679 :     if (OidIsValid(anycompatible_multirange_typeid))
                               1940                 :                :     {
                               1941         [ +  + ]:             48 :         if (OidIsValid(anycompatible_range_typeid))
                               1942                 :                :         {
                               1943         [ +  + ]:              6 :             if (anycompatible_multirange_typelem !=
                               1944                 :                :                 anycompatible_range_typeid)
                               1945                 :              3 :                 return false;
                               1946                 :                :         }
                               1947                 :                :         else
                               1948                 :                :         {
                               1949                 :             42 :             anycompatible_range_typeid = anycompatible_multirange_typelem;
                               1950                 :             42 :             anycompatible_range_typelem = get_range_subtype(anycompatible_range_typeid);
                               1951         [ -  + ]:             42 :             if (!OidIsValid(anycompatible_range_typelem))
  992 tgl@sss.pgh.pa.us        1952                 :UBC           0 :                 return false;   /* not a range type */
                               1953                 :                :             /* collect the subtype for common-supertype choice */
  992 tgl@sss.pgh.pa.us        1954                 :CBC          42 :             anycompatible_actual_types[n_anycompatible_args++] =
                               1955                 :                :                 anycompatible_range_typelem;
                               1956                 :                :         }
                               1957                 :                :     }
                               1958                 :                : 
                               1959                 :                :     /* Check matching of ANYCOMPATIBLE-family arguments, if any */
 1487                          1960         [ +  + ]:          25676 :     if (n_anycompatible_args > 0)
                               1961                 :                :     {
                               1962                 :                :         Oid         anycompatible_typeid;
                               1963                 :                : 
                               1964                 :                :         anycompatible_typeid =
                               1965                 :           1654 :             select_common_type_from_oids(n_anycompatible_args,
                               1966                 :                :                                          anycompatible_actual_types,
                               1967                 :                :                                          true);
                               1968                 :                : 
                               1969         [ +  + ]:           1654 :         if (!OidIsValid(anycompatible_typeid))
  806                          1970                 :            310 :             return false;       /* there's definitely no common supertype */
                               1971                 :                : 
                               1972                 :                :         /* We have to verify that the selected type actually works */
                               1973         [ +  + ]:           1344 :         if (!verify_common_type_from_oids(anycompatible_typeid,
                               1974                 :                :                                           n_anycompatible_args,
                               1975                 :                :                                           anycompatible_actual_types))
                               1976                 :              6 :             return false;
                               1977                 :                : 
 1487                          1978         [ +  + ]:           1338 :         if (have_anycompatible_nonarray)
                               1979                 :                :         {
                               1980                 :                :             /*
                               1981                 :                :              * require the anycompatible type to not be an array or domain
                               1982                 :                :              * over array
                               1983                 :                :              */
                               1984         [ +  + ]:              9 :             if (type_is_array_domain(anycompatible_typeid))
                               1985                 :              3 :                 return false;
                               1986                 :                :         }
                               1987                 :                : 
                               1988                 :                :         /*
                               1989                 :                :          * The anycompatible type must exactly match the range element type,
                               1990                 :                :          * if we were able to identify one. This checks compatibility for
                               1991                 :                :          * anycompatiblemultirange too since that also sets
                               1992                 :                :          * anycompatible_range_typelem above.
                               1993                 :                :          */
                               1994   [ +  +  +  + ]:           1335 :         if (OidIsValid(anycompatible_range_typelem) &&
                               1995                 :                :             anycompatible_range_typelem != anycompatible_typeid)
                               1996                 :             21 :             return false;
                               1997                 :                :     }
                               1998                 :                : 
                               1999                 :                :     /* Looks valid */
 7677                          2000                 :          25336 :     return true;
                               2001                 :                : }
                               2002                 :                : 
                               2003                 :                : /*
                               2004                 :                :  * enforce_generic_type_consistency()
                               2005                 :                :  *      Make sure a polymorphic function is legally callable, and
                               2006                 :                :  *      deduce actual argument and result types.
                               2007                 :                :  *
                               2008                 :                :  * If any polymorphic pseudotype is used in a function's arguments or
                               2009                 :                :  * return type, we make sure the actual data types are consistent with
                               2010                 :                :  * each other.  The argument consistency rules are shown above for
                               2011                 :                :  * check_generic_type_consistency().
                               2012                 :                :  *
                               2013                 :                :  * If we have UNKNOWN input (ie, an untyped literal) for any polymorphic
                               2014                 :                :  * argument, we attempt to deduce the actual type it should have.  If
                               2015                 :                :  * successful, we alter that position of declared_arg_types[] so that
                               2016                 :                :  * make_fn_arguments will coerce the literal to the right thing.
                               2017                 :                :  *
                               2018                 :                :  * If we have polymorphic arguments of the ANYCOMPATIBLE family,
                               2019                 :                :  * we similarly alter declared_arg_types[] entries to show the resolved
                               2020                 :                :  * common supertype, so that make_fn_arguments will coerce the actual
                               2021                 :                :  * arguments to the proper type.
                               2022                 :                :  *
                               2023                 :                :  * Rules are applied to the function's return type (possibly altering it)
                               2024                 :                :  * if it is declared as a polymorphic type and there is at least one
                               2025                 :                :  * polymorphic argument type:
                               2026                 :                :  *
                               2027                 :                :  * 1) If return type is ANYELEMENT, and any argument is ANYELEMENT, use the
                               2028                 :                :  *    argument's actual type as the function's return type.
                               2029                 :                :  * 2) If return type is ANYARRAY, and any argument is ANYARRAY, use the
                               2030                 :                :  *    argument's actual type as the function's return type.
                               2031                 :                :  * 3) Similarly, if return type is ANYRANGE or ANYMULTIRANGE, and any
                               2032                 :                :  *    argument is ANYRANGE or ANYMULTIRANGE, use that argument's actual type
                               2033                 :                :  *    (or the corresponding range or multirange type) as the function's return
                               2034                 :                :  *    type.
                               2035                 :                :  * 4) Otherwise, if return type is ANYELEMENT or ANYARRAY, and there is
                               2036                 :                :  *    at least one ANYELEMENT, ANYARRAY, ANYRANGE, or ANYMULTIRANGE input,
                               2037                 :                :  *    deduce the return type from those inputs, or throw error if we can't.
                               2038                 :                :  * 5) Otherwise, if return type is ANYRANGE or ANYMULTIRANGE, throw error.
                               2039                 :                :  *    (We have no way to select a specific range type if the arguments don't
                               2040                 :                :  *    include ANYRANGE or ANYMULTIRANGE.)
                               2041                 :                :  * 6) ANYENUM is treated the same as ANYELEMENT except that if it is used
                               2042                 :                :  *    (alone or in combination with plain ANYELEMENT), we add the extra
                               2043                 :                :  *    condition that the ANYELEMENT type must be an enum.
                               2044                 :                :  * 7) ANYNONARRAY is treated the same as ANYELEMENT except that if it is used,
                               2045                 :                :  *    we add the extra condition that the ANYELEMENT type must not be an array.
                               2046                 :                :  *    (This is a no-op if used in combination with ANYARRAY or ANYENUM, but
                               2047                 :                :  *    is an extra restriction if not.)
                               2048                 :                :  * 8) ANYCOMPATIBLE, ANYCOMPATIBLEARRAY, and ANYCOMPATIBLENONARRAY are handled
                               2049                 :                :  *    by resolving the common supertype of those arguments (or their element
                               2050                 :                :  *    types, for array inputs), and then coercing all those arguments to the
                               2051                 :                :  *    common supertype, or the array type over the common supertype for
                               2052                 :                :  *    ANYCOMPATIBLEARRAY.
                               2053                 :                :  * 9) For ANYCOMPATIBLERANGE and ANYCOMPATIBLEMULTIRANGE, there must be at
                               2054                 :                :  *    least one non-UNKNOWN input matching those arguments, and all such
                               2055                 :                :  *    inputs must be the same range type (or its multirange type, as
                               2056                 :                :  *    appropriate), since we cannot deduce a range type from non-range types.
                               2057                 :                :  *    Furthermore, the range type's subtype is included while choosing the
                               2058                 :                :  *    common supertype for ANYCOMPATIBLE et al, and it must exactly match
                               2059                 :                :  *    that common supertype.
                               2060                 :                :  *
                               2061                 :                :  * Domains over arrays or ranges match ANYARRAY or ANYRANGE arguments,
                               2062                 :                :  * respectively, and are immediately flattened to their base type.  (In
                               2063                 :                :  * particular, if the return type is also ANYARRAY or ANYRANGE, we'll set
                               2064                 :                :  * it to the base type not the domain type.)  The same is true for
                               2065                 :                :  * ANYMULTIRANGE, ANYCOMPATIBLEARRAY, ANYCOMPATIBLERANGE, and
                               2066                 :                :  * ANYCOMPATIBLEMULTIRANGE.
                               2067                 :                :  *
                               2068                 :                :  * When allow_poly is false, we are not expecting any of the actual_arg_types
                               2069                 :                :  * to be polymorphic, and we should not return a polymorphic result type
                               2070                 :                :  * either.  When allow_poly is true, it is okay to have polymorphic "actual"
                               2071                 :                :  * arg types, and we can return a matching polymorphic type as the result.
                               2072                 :                :  * (This case is currently used only to check compatibility of an aggregate's
                               2073                 :                :  * declaration with the underlying transfn.)
                               2074                 :                :  *
                               2075                 :                :  * A special case is that we could see ANYARRAY as an actual_arg_type even
                               2076                 :                :  * when allow_poly is false (this is possible only because pg_statistic has
                               2077                 :                :  * columns shown as anyarray in the catalogs).  We allow this to match a
                               2078                 :                :  * declared ANYARRAY argument, but only if there is no other polymorphic
                               2079                 :                :  * argument that we would need to match it with, and no need to determine
                               2080                 :                :  * the element type to infer the result type.  Note this means that functions
                               2081                 :                :  * taking ANYARRAY had better behave sanely if applied to the pg_statistic
                               2082                 :                :  * columns; they can't just assume that successive inputs are of the same
                               2083                 :                :  * actual element type.  There is no similar logic for ANYCOMPATIBLEARRAY;
                               2084                 :                :  * there isn't a need for it since there are no catalog columns of that type,
                               2085                 :                :  * so we won't see it as input.  We could consider matching an actual ANYARRAY
                               2086                 :                :  * input to an ANYCOMPATIBLEARRAY argument, but at present that seems useless
                               2087                 :                :  * as well, since there's no value in using ANYCOMPATIBLEARRAY unless there's
                               2088                 :                :  * at least one other ANYCOMPATIBLE-family argument or result.
                               2089                 :                :  *
                               2090                 :                :  * Also, if there are no arguments declared to be of polymorphic types,
                               2091                 :                :  * we'll return the rettype unmodified even if it's polymorphic.  This should
                               2092                 :                :  * never occur for user-declared functions, because CREATE FUNCTION prevents
                               2093                 :                :  * it.  But it does happen for some built-in functions, such as array_in().
                               2094                 :                :  */
                               2095                 :                : Oid
 2000 peter_e@gmx.net          2096                 :         478987 : enforce_generic_type_consistency(const Oid *actual_arg_types,
                               2097                 :                :                                  Oid *declared_arg_types,
                               2098                 :                :                                  int nargs,
                               2099                 :                :                                  Oid rettype,
                               2100                 :                :                                  bool allow_poly)
                               2101                 :                : {
 1487 tgl@sss.pgh.pa.us        2102                 :         478987 :     bool        have_poly_anycompatible = false;
 1489                          2103                 :         478987 :     bool        have_poly_unknowns = false;
 7677                          2104                 :         478987 :     Oid         elem_typeid = InvalidOid;
                               2105                 :         478987 :     Oid         array_typeid = InvalidOid;
 4546 heikki.linnakangas@i     2106                 :         478987 :     Oid         range_typeid = InvalidOid;
 1211 akorotkov@postgresql     2107                 :         478987 :     Oid         multirange_typeid = InvalidOid;
 1487 tgl@sss.pgh.pa.us        2108                 :         478987 :     Oid         anycompatible_typeid = InvalidOid;
                               2109                 :         478987 :     Oid         anycompatible_array_typeid = InvalidOid;
                               2110                 :         478987 :     Oid         anycompatible_range_typeid = InvalidOid;
                               2111                 :         478987 :     Oid         anycompatible_range_typelem = InvalidOid;
 1211 akorotkov@postgresql     2112                 :         478987 :     Oid         anycompatible_multirange_typeid = InvalidOid;
                               2113                 :         478987 :     Oid         anycompatible_multirange_typelem = InvalidOid;
 6157 tgl@sss.pgh.pa.us        2114                 :         478987 :     bool        have_anynonarray = (rettype == ANYNONARRAYOID);
 6222                          2115                 :         478987 :     bool        have_anyenum = (rettype == ANYENUMOID);
  992                          2116                 :         478987 :     bool        have_anymultirange = (rettype == ANYMULTIRANGEOID);
 1487                          2117                 :         478987 :     bool        have_anycompatible_nonarray = (rettype == ANYCOMPATIBLENONARRAYOID);
                               2118                 :         478987 :     bool        have_anycompatible_array = (rettype == ANYCOMPATIBLEARRAYOID);
                               2119                 :         478987 :     bool        have_anycompatible_range = (rettype == ANYCOMPATIBLERANGEOID);
  992                          2120                 :         478987 :     bool        have_anycompatible_multirange = (rettype == ANYCOMPATIBLEMULTIRANGEOID);
 1487                          2121                 :         478987 :     int         n_poly_args = 0;    /* this counts all family-1 arguments */
                               2122                 :         478987 :     int         n_anycompatible_args = 0;   /* this counts only non-unknowns */
                               2123                 :                :     Oid         anycompatible_actual_types[FUNC_MAX_ARGS];
                               2124                 :                : 
                               2125                 :                :     /*
                               2126                 :                :      * Loop through the arguments to see if we have any that are polymorphic.
                               2127                 :                :      * If so, require the actual types to be consistent.
                               2128                 :                :      */
                               2129         [ -  + ]:         478987 :     Assert(nargs <= FUNC_MAX_ARGS);
 1489                          2130         [ +  + ]:        1372165 :     for (int j = 0; j < nargs; j++)
                               2131                 :                :     {
 6157                          2132                 :         893178 :         Oid         decl_type = declared_arg_types[j];
 7559 bruce@momjian.us         2133                 :         893178 :         Oid         actual_type = actual_arg_types[j];
                               2134                 :                : 
 6157 tgl@sss.pgh.pa.us        2135   [ +  +  +  + ]:         893178 :         if (decl_type == ANYELEMENTOID ||
                               2136         [ +  + ]:         882313 :             decl_type == ANYNONARRAYOID ||
                               2137                 :                :             decl_type == ANYENUMOID)
                               2138                 :                :         {
 1489                          2139                 :          11284 :             n_poly_args++;
 6157                          2140         [ +  + ]:          11284 :             if (decl_type == ANYNONARRAYOID)
                               2141                 :           7841 :                 have_anynonarray = true;
                               2142         [ +  + ]:           3443 :             else if (decl_type == ANYENUMOID)
 6222                          2143                 :            419 :                 have_anyenum = true;
 7677                          2144         [ +  + ]:          11284 :             if (actual_type == UNKNOWNOID)
                               2145                 :                :             {
 1489                          2146                 :            360 :                 have_poly_unknowns = true;
 7677                          2147                 :            360 :                 continue;
                               2148                 :                :             }
 5938                          2149   [ +  +  +  + ]:          10924 :             if (allow_poly && decl_type == actual_type)
                               2150                 :             88 :                 continue;       /* no new information here */
 7677                          2151   [ +  +  -  + ]:          10836 :             if (OidIsValid(elem_typeid) && actual_type != elem_typeid)
 7575 tgl@sss.pgh.pa.us        2152         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2153                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2154                 :                :                          errmsg("arguments declared \"%s\" are not all alike", "anyelement"),
                               2155                 :                :                          errdetail("%s versus %s",
                               2156                 :                :                                    format_type_be(elem_typeid),
                               2157                 :                :                                    format_type_be(actual_type))));
 7677 tgl@sss.pgh.pa.us        2158                 :CBC       10836 :             elem_typeid = actual_type;
                               2159                 :                :         }
 6157                          2160         [ +  + ]:         881894 :         else if (decl_type == ANYARRAYOID)
                               2161                 :                :         {
 1489                          2162                 :          15544 :             n_poly_args++;
 7677                          2163         [ +  + ]:          15544 :             if (actual_type == UNKNOWNOID)
                               2164                 :                :             {
 1489                          2165                 :           1980 :                 have_poly_unknowns = true;
 7677                          2166                 :           1980 :                 continue;
                               2167                 :                :             }
 5938                          2168   [ +  +  +  + ]:          13564 :             if (allow_poly && decl_type == actual_type)
                               2169                 :             49 :                 continue;       /* no new information here */
 2489                          2170                 :          13515 :             actual_type = getBaseType(actual_type); /* flatten domains */
 7677                          2171   [ +  +  -  + ]:          13515 :             if (OidIsValid(array_typeid) && actual_type != array_typeid)
 7575 tgl@sss.pgh.pa.us        2172         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2173                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2174                 :                :                          errmsg("arguments declared \"%s\" are not all alike", "anyarray"),
                               2175                 :                :                          errdetail("%s versus %s",
                               2176                 :                :                                    format_type_be(array_typeid),
                               2177                 :                :                                    format_type_be(actual_type))));
 7677 tgl@sss.pgh.pa.us        2178                 :CBC       13515 :             array_typeid = actual_type;
                               2179                 :                :         }
 4546 heikki.linnakangas@i     2180         [ +  + ]:         866350 :         else if (decl_type == ANYRANGEOID)
                               2181                 :                :         {
 1489 tgl@sss.pgh.pa.us        2182                 :           3553 :             n_poly_args++;
 4546 heikki.linnakangas@i     2183         [ +  + ]:           3553 :             if (actual_type == UNKNOWNOID)
                               2184                 :                :             {
 1489 tgl@sss.pgh.pa.us        2185                 :            236 :                 have_poly_unknowns = true;
 4546 heikki.linnakangas@i     2186                 :            236 :                 continue;
                               2187                 :                :             }
                               2188   [ -  +  -  - ]:           3317 :             if (allow_poly && decl_type == actual_type)
 4546 heikki.linnakangas@i     2189                 :UBC           0 :                 continue;       /* no new information here */
 2489 tgl@sss.pgh.pa.us        2190                 :CBC        3317 :             actual_type = getBaseType(actual_type); /* flatten domains */
 4546 heikki.linnakangas@i     2191   [ +  +  -  + ]:           3317 :             if (OidIsValid(range_typeid) && actual_type != range_typeid)
 4546 heikki.linnakangas@i     2192         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2193                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2194                 :                :                          errmsg("arguments declared \"%s\" are not all alike", "anyrange"),
                               2195                 :                :                          errdetail("%s versus %s",
                               2196                 :                :                                    format_type_be(range_typeid),
                               2197                 :                :                                    format_type_be(actual_type))));
 4546 heikki.linnakangas@i     2198                 :CBC        3317 :             range_typeid = actual_type;
                               2199                 :                :         }
 1211 akorotkov@postgresql     2200         [ +  + ]:         862797 :         else if (decl_type == ANYMULTIRANGEOID)
                               2201                 :                :         {
                               2202                 :           2416 :             n_poly_args++;
  992 tgl@sss.pgh.pa.us        2203                 :           2416 :             have_anymultirange = true;
 1211 akorotkov@postgresql     2204         [ +  + ]:           2416 :             if (actual_type == UNKNOWNOID)
                               2205                 :                :             {
                               2206                 :            132 :                 have_poly_unknowns = true;
                               2207                 :            132 :                 continue;
                               2208                 :                :             }
                               2209   [ -  +  -  - ]:           2284 :             if (allow_poly && decl_type == actual_type)
 1211 akorotkov@postgresql     2210                 :UBC           0 :                 continue;       /* no new information here */
 1211 akorotkov@postgresql     2211                 :CBC        2284 :             actual_type = getBaseType(actual_type); /* flatten domains */
                               2212   [ +  +  -  + ]:           2284 :             if (OidIsValid(multirange_typeid) && actual_type != multirange_typeid)
 1211 akorotkov@postgresql     2213         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2214                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2215                 :                :                          errmsg("arguments declared \"%s\" are not all alike", "anymultirange"),
                               2216                 :                :                          errdetail("%s versus %s",
                               2217                 :                :                                    format_type_be(multirange_typeid),
                               2218                 :                :                                    format_type_be(actual_type))));
 1211 akorotkov@postgresql     2219                 :CBC        2284 :             multirange_typeid = actual_type;
                               2220                 :                :         }
 1487 tgl@sss.pgh.pa.us        2221   [ +  +  +  + ]:         860381 :         else if (decl_type == ANYCOMPATIBLEOID ||
                               2222                 :                :                  decl_type == ANYCOMPATIBLENONARRAYOID)
                               2223                 :                :         {
                               2224                 :           1053 :             have_poly_anycompatible = true;
                               2225         [ +  + ]:           1053 :             if (decl_type == ANYCOMPATIBLENONARRAYOID)
                               2226                 :             12 :                 have_anycompatible_nonarray = true;
                               2227         [ +  + ]:           1053 :             if (actual_type == UNKNOWNOID)
                               2228                 :            484 :                 continue;
                               2229   [ +  +  +  + ]:            569 :             if (allow_poly && decl_type == actual_type)
                               2230                 :              4 :                 continue;       /* no new information here */
                               2231                 :                :             /* collect the actual types of non-unknown COMPATIBLE args */
                               2232                 :            565 :             anycompatible_actual_types[n_anycompatible_args++] = actual_type;
                               2233                 :                :         }
                               2234         [ +  + ]:         859328 :         else if (decl_type == ANYCOMPATIBLEARRAYOID)
                               2235                 :                :         {
                               2236                 :                :             Oid         anycompatible_elem_type;
                               2237                 :                : 
                               2238                 :           2417 :             have_poly_anycompatible = true;
                               2239                 :           2417 :             have_anycompatible_array = true;
                               2240         [ +  + ]:           2417 :             if (actual_type == UNKNOWNOID)
                               2241                 :             15 :                 continue;
                               2242   [ +  +  +  + ]:           2402 :             if (allow_poly && decl_type == actual_type)
                               2243                 :              4 :                 continue;       /* no new information here */
                               2244                 :           2398 :             actual_type = getBaseType(actual_type); /* flatten domains */
                               2245                 :           2398 :             anycompatible_elem_type = get_element_type(actual_type);
                               2246         [ -  + ]:           2398 :             if (!OidIsValid(anycompatible_elem_type))
 1487 tgl@sss.pgh.pa.us        2247         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2248                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2249                 :                :                          errmsg("argument declared %s is not an array but type %s",
                               2250                 :                :                                 "anycompatiblearray",
                               2251                 :                :                                 format_type_be(actual_type))));
                               2252                 :                :             /* collect the element type for common-supertype choice */
 1487 tgl@sss.pgh.pa.us        2253                 :CBC        2398 :             anycompatible_actual_types[n_anycompatible_args++] = anycompatible_elem_type;
                               2254                 :                :         }
                               2255         [ +  + ]:         856911 :         else if (decl_type == ANYCOMPATIBLERANGEOID)
                               2256                 :                :         {
                               2257                 :             69 :             have_poly_anycompatible = true;
                               2258                 :             69 :             have_anycompatible_range = true;
                               2259         [ +  + ]:             69 :             if (actual_type == UNKNOWNOID)
                               2260                 :              6 :                 continue;
                               2261   [ -  +  -  - ]:             63 :             if (allow_poly && decl_type == actual_type)
 1487 tgl@sss.pgh.pa.us        2262                 :UBC           0 :                 continue;       /* no new information here */
 1487 tgl@sss.pgh.pa.us        2263                 :CBC          63 :             actual_type = getBaseType(actual_type); /* flatten domains */
                               2264         [ +  + ]:             63 :             if (OidIsValid(anycompatible_range_typeid))
                               2265                 :                :             {
                               2266                 :                :                 /* All ANYCOMPATIBLERANGE arguments must be the same type */
                               2267         [ -  + ]:              3 :                 if (anycompatible_range_typeid != actual_type)
 1487 tgl@sss.pgh.pa.us        2268         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2269                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2270                 :                :                              errmsg("arguments declared \"%s\" are not all alike", "anycompatiblerange"),
                               2271                 :                :                              errdetail("%s versus %s",
                               2272                 :                :                                        format_type_be(anycompatible_range_typeid),
                               2273                 :                :                                        format_type_be(actual_type))));
                               2274                 :                :             }
                               2275                 :                :             else
                               2276                 :                :             {
 1487 tgl@sss.pgh.pa.us        2277                 :CBC          60 :                 anycompatible_range_typeid = actual_type;
                               2278                 :             60 :                 anycompatible_range_typelem = get_range_subtype(actual_type);
                               2279         [ -  + ]:             60 :                 if (!OidIsValid(anycompatible_range_typelem))
 1487 tgl@sss.pgh.pa.us        2280         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2281                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2282                 :                :                              errmsg("argument declared %s is not a range type but type %s",
                               2283                 :                :                                     "anycompatiblerange",
                               2284                 :                :                                     format_type_be(actual_type))));
                               2285                 :                :                 /* collect the subtype for common-supertype choice */
 1487 tgl@sss.pgh.pa.us        2286                 :CBC          60 :                 anycompatible_actual_types[n_anycompatible_args++] = anycompatible_range_typelem;
                               2287                 :                :             }
                               2288                 :                :         }
 1211 akorotkov@postgresql     2289         [ +  + ]:         856842 :         else if (decl_type == ANYCOMPATIBLEMULTIRANGEOID)
                               2290                 :                :         {
                               2291                 :             48 :             have_poly_anycompatible = true;
  992 tgl@sss.pgh.pa.us        2292                 :             48 :             have_anycompatible_multirange = true;
 1211 akorotkov@postgresql     2293         [ +  + ]:             48 :             if (actual_type == UNKNOWNOID)
                               2294                 :              9 :                 continue;
                               2295   [ -  +  -  - ]:             39 :             if (allow_poly && decl_type == actual_type)
 1211 akorotkov@postgresql     2296                 :UBC           0 :                 continue;       /* no new information here */
 1211 akorotkov@postgresql     2297                 :CBC          39 :             actual_type = getBaseType(actual_type); /* flatten domains */
                               2298         [ +  + ]:             39 :             if (OidIsValid(anycompatible_multirange_typeid))
                               2299                 :                :             {
                               2300                 :                :                 /* All ANYCOMPATIBLEMULTIRANGE arguments must be the same type */
                               2301         [ -  + ]:              3 :                 if (anycompatible_multirange_typeid != actual_type)
 1211 akorotkov@postgresql     2302         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2303                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2304                 :                :                              errmsg("arguments declared \"%s\" are not all alike", "anycompatiblemultirange"),
                               2305                 :                :                              errdetail("%s versus %s",
                               2306                 :                :                                        format_type_be(anycompatible_multirange_typeid),
                               2307                 :                :                                        format_type_be(actual_type))));
                               2308                 :                :             }
                               2309                 :                :             else
                               2310                 :                :             {
 1211 akorotkov@postgresql     2311                 :CBC          36 :                 anycompatible_multirange_typeid = actual_type;
                               2312                 :             36 :                 anycompatible_multirange_typelem = get_multirange_range(actual_type);
                               2313         [ -  + ]:             36 :                 if (!OidIsValid(anycompatible_multirange_typelem))
 1211 akorotkov@postgresql     2314         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2315                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2316                 :                :                              errmsg("argument declared %s is not a multirange type but type %s",
                               2317                 :                :                                     "anycompatiblemultirange",
                               2318                 :                :                                     format_type_be(actual_type))));
                               2319                 :                :                 /* we'll consider the subtype below */
                               2320                 :                :             }
                               2321                 :                :         }
                               2322                 :                :     }
                               2323                 :                : 
                               2324                 :                :     /*
                               2325                 :                :      * Fast Track: if none of the arguments are polymorphic, return the
                               2326                 :                :      * unmodified rettype.  Not our job to resolve it if it's polymorphic.
                               2327                 :                :      */
 1487 tgl@sss.pgh.pa.us        2328   [ +  +  +  + ]:CBC      478987 :     if (n_poly_args == 0 && !have_poly_anycompatible)
 7677                          2329                 :         450628 :         return rettype;
                               2330                 :                : 
                               2331                 :                :     /* Check matching of family-1 polymorphic arguments, if any */
 1489                          2332         [ +  + ]:          28359 :     if (n_poly_args)
                               2333                 :                :     {
                               2334                 :                :         /* Get the element type based on the array type, if we have one */
                               2335         [ +  + ]:          26582 :         if (OidIsValid(array_typeid))
                               2336                 :                :         {
                               2337                 :                :             Oid         array_typelem;
                               2338                 :                : 
                               2339         [ +  + ]:          12619 :             if (array_typeid == ANYARRAYOID)
                               2340                 :                :             {
                               2341                 :                :                 /*
                               2342                 :                :                  * Special case for matching ANYARRAY input to an ANYARRAY
                               2343                 :                :                  * argument: allow it iff no other arguments are family-1
                               2344                 :                :                  * polymorphics (otherwise we couldn't be sure whether the
                               2345                 :                :                  * array element type matches up) and the result type doesn't
                               2346                 :                :                  * require us to infer a specific element type.
                               2347                 :                :                  */
                               2348   [ +  -  +  + ]:             21 :                 if (n_poly_args != 1 ||
 1487                          2349         [ +  + ]:              9 :                     (rettype != ANYARRAYOID &&
                               2350   [ +  -  +  -  :              3 :                      IsPolymorphicTypeFamily1(rettype)))
                                     +  -  +  -  -  
                                                 + ]
 1489                          2351         [ +  - ]:              6 :                     ereport(ERROR,
                               2352                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2353                 :                :                              errmsg("cannot determine element type of \"anyarray\" argument")));
                               2354                 :             15 :                 array_typelem = ANYELEMENTOID;
                               2355                 :                :             }
                               2356                 :                :             else
                               2357                 :                :             {
                               2358                 :          12598 :                 array_typelem = get_element_type(array_typeid);
                               2359         [ -  + ]:          12598 :                 if (!OidIsValid(array_typelem))
 1489 tgl@sss.pgh.pa.us        2360         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2361                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2362                 :                :                              errmsg("argument declared %s is not an array but type %s",
                               2363                 :                :                                     "anyarray", format_type_be(array_typeid))));
                               2364                 :                :             }
                               2365                 :                : 
 1489 tgl@sss.pgh.pa.us        2366         [ +  + ]:CBC       12613 :             if (!OidIsValid(elem_typeid))
                               2367                 :                :             {
                               2368                 :                :                 /*
                               2369                 :                :                  * if we don't have an element type yet, use the one we just
                               2370                 :                :                  * got
                               2371                 :                :                  */
                               2372                 :          12573 :                 elem_typeid = array_typelem;
                               2373                 :                :             }
                               2374         [ -  + ]:             40 :             else if (array_typelem != elem_typeid)
                               2375                 :                :             {
                               2376                 :                :                 /* otherwise, they better match */
 5600 tgl@sss.pgh.pa.us        2377         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2378                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2379                 :                :                          errmsg("argument declared %s is not consistent with argument declared %s",
                               2380                 :                :                                 "anyarray", "anyelement"),
                               2381                 :                :                          errdetail("%s versus %s",
                               2382                 :                :                                    format_type_be(array_typeid),
                               2383                 :                :                                    format_type_be(elem_typeid))));
                               2384                 :                :             }
                               2385                 :                :         }
                               2386                 :                : 
                               2387                 :                :         /* Deduce range type from multirange type, or vice versa */
 1211 akorotkov@postgresql     2388         [ +  + ]:CBC       26576 :         if (OidIsValid(multirange_typeid))
                               2389                 :                :         {
                               2390                 :                :             Oid         multirange_typelem;
                               2391                 :                : 
                               2392                 :           1705 :             multirange_typelem = get_multirange_range(multirange_typeid);
                               2393         [ -  + ]:           1705 :             if (!OidIsValid(multirange_typelem))
 1211 akorotkov@postgresql     2394         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2395                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2396                 :                :                          errmsg("argument declared %s is not a multirange type but type %s",
                               2397                 :                :                                 "anymultirange",
                               2398                 :                :                                 format_type_be(multirange_typeid))));
                               2399                 :                : 
 1211 akorotkov@postgresql     2400         [ +  + ]:CBC        1705 :             if (!OidIsValid(range_typeid))
                               2401                 :                :             {
                               2402                 :                :                 /* if we don't have a range type yet, use the one we just got */
                               2403                 :           1050 :                 range_typeid = multirange_typelem;
                               2404                 :                :             }
                               2405         [ -  + ]:            655 :             else if (multirange_typelem != range_typeid)
                               2406                 :                :             {
                               2407                 :                :                 /* otherwise, they better match */
 1211 akorotkov@postgresql     2408         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2409                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2410                 :                :                          errmsg("argument declared %s is not consistent with argument declared %s",
                               2411                 :                :                                 "anymultirange", "anyrange"),
                               2412                 :                :                          errdetail("%s versus %s",
                               2413                 :                :                                    format_type_be(multirange_typeid),
                               2414                 :                :                                    format_type_be(range_typeid))));
                               2415                 :                :             }
                               2416                 :                :         }
  992 tgl@sss.pgh.pa.us        2417   [ +  +  +  + ]:CBC       24871 :         else if (have_anymultirange && OidIsValid(range_typeid))
                               2418                 :                :         {
                               2419                 :            145 :             multirange_typeid = get_range_multirange(range_typeid);
                               2420                 :                :             /* We'll complain below if that didn't work */
                               2421                 :                :         }
                               2422                 :                : 
                               2423                 :                :         /* Get the element type based on the range type, if we have one */
                               2424         [ +  + ]:          26576 :         if (OidIsValid(range_typeid))
                               2425                 :                :         {
                               2426                 :                :             Oid         range_typelem;
                               2427                 :                : 
                               2428                 :           3432 :             range_typelem = get_range_subtype(range_typeid);
                               2429         [ -  + ]:           3432 :             if (!OidIsValid(range_typelem))
  992 tgl@sss.pgh.pa.us        2430         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2431                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2432                 :                :                          errmsg("argument declared %s is not a range type but type %s",
                               2433                 :                :                                 "anyrange",
                               2434                 :                :                                 format_type_be(range_typeid))));
                               2435                 :                : 
 1211 akorotkov@postgresql     2436         [ +  + ]:CBC        3432 :             if (!OidIsValid(elem_typeid))
                               2437                 :                :             {
                               2438                 :                :                 /*
                               2439                 :                :                  * if we don't have an element type yet, use the one we just
                               2440                 :                :                  * got
                               2441                 :                :                  */
                               2442                 :           3255 :                 elem_typeid = range_typelem;
                               2443                 :                :             }
                               2444         [ -  + ]:            177 :             else if (range_typelem != elem_typeid)
                               2445                 :                :             {
                               2446                 :                :                 /* otherwise, they better match */
 1211 akorotkov@postgresql     2447         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2448                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2449                 :                :                          errmsg("argument declared %s is not consistent with argument declared %s",
                               2450                 :                :                                 "anyrange", "anyelement"),
                               2451                 :                :                          errdetail("%s versus %s",
                               2452                 :                :                                    format_type_be(range_typeid),
                               2453                 :                :                                    format_type_be(elem_typeid))));
                               2454                 :                :             }
                               2455                 :                :         }
                               2456                 :                : 
 4546 heikki.linnakangas@i     2457         [ +  + ]:CBC       26576 :         if (!OidIsValid(elem_typeid))
                               2458                 :                :         {
 1489 tgl@sss.pgh.pa.us        2459         [ +  + ]:            110 :             if (allow_poly)
                               2460                 :                :             {
                               2461                 :             98 :                 elem_typeid = ANYELEMENTOID;
                               2462                 :             98 :                 array_typeid = ANYARRAYOID;
                               2463                 :             98 :                 range_typeid = ANYRANGEOID;
 1211 akorotkov@postgresql     2464                 :             98 :                 multirange_typeid = ANYMULTIRANGEOID;
                               2465                 :                :             }
                               2466                 :                :             else
                               2467                 :                :             {
                               2468                 :                :                 /*
                               2469                 :                :                  * Only way to get here is if all the family-1 polymorphic
                               2470                 :                :                  * arguments have UNKNOWN inputs.
                               2471                 :                :                  */
 1489 tgl@sss.pgh.pa.us        2472         [ +  - ]:             12 :                 ereport(ERROR,
                               2473                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2474                 :                :                          errmsg("could not determine polymorphic type because input has type %s",
                               2475                 :                :                                 "unknown")));
                               2476                 :                :             }
                               2477                 :                :         }
                               2478                 :                : 
                               2479   [ +  +  +  - ]:          26564 :         if (have_anynonarray && elem_typeid != ANYELEMENTOID)
                               2480                 :                :         {
                               2481                 :                :             /*
                               2482                 :                :              * require the element type to not be an array or domain over
                               2483                 :                :              * array
                               2484                 :                :              */
                               2485         [ -  + ]:           7665 :             if (type_is_array_domain(elem_typeid))
 1489 tgl@sss.pgh.pa.us        2486         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2487                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2488                 :                :                          errmsg("type matched to anynonarray is an array type: %s",
                               2489                 :                :                                 format_type_be(elem_typeid))));
                               2490                 :                :         }
                               2491                 :                : 
 1489 tgl@sss.pgh.pa.us        2492   [ +  +  +  - ]:CBC       26564 :         if (have_anyenum && elem_typeid != ANYELEMENTOID)
                               2493                 :                :         {
                               2494                 :                :             /* require the element type to be an enum */
                               2495         [ -  + ]:            286 :             if (!type_is_enum(elem_typeid))
 1489 tgl@sss.pgh.pa.us        2496         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2497                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2498                 :                :                          errmsg("type matched to anyenum is not an enum type: %s",
                               2499                 :                :                                 format_type_be(elem_typeid))));
                               2500                 :                :         }
                               2501                 :                :     }
                               2502                 :                : 
                               2503                 :                :     /* Check matching of family-2 polymorphic arguments, if any */
 1487 tgl@sss.pgh.pa.us        2504         [ +  + ]:CBC       28341 :     if (have_poly_anycompatible)
                               2505                 :                :     {
                               2506                 :                :         /* Deduce range type from multirange type, or vice versa */
  992                          2507         [ +  + ]:           1804 :         if (OidIsValid(anycompatible_multirange_typeid))
                               2508                 :                :         {
                               2509         [ +  + ]:             36 :             if (OidIsValid(anycompatible_range_typeid))
                               2510                 :                :             {
                               2511         [ -  + ]:              3 :                 if (anycompatible_multirange_typelem !=
                               2512                 :                :                     anycompatible_range_typeid)
  992 tgl@sss.pgh.pa.us        2513         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2514                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2515                 :                :                              errmsg("argument declared %s is not consistent with argument declared %s",
                               2516                 :                :                                     "anycompatiblemultirange",
                               2517                 :                :                                     "anycompatiblerange"),
                               2518                 :                :                              errdetail("%s versus %s",
                               2519                 :                :                                        format_type_be(anycompatible_multirange_typeid),
                               2520                 :                :                                        format_type_be(anycompatible_range_typeid))));
                               2521                 :                :             }
                               2522                 :                :             else
                               2523                 :                :             {
  992 tgl@sss.pgh.pa.us        2524                 :CBC          33 :                 anycompatible_range_typeid = anycompatible_multirange_typelem;
                               2525                 :             33 :                 anycompatible_range_typelem = get_range_subtype(anycompatible_range_typeid);
                               2526         [ -  + ]:             33 :                 if (!OidIsValid(anycompatible_range_typelem))
  992 tgl@sss.pgh.pa.us        2527         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2528                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2529                 :                :                              errmsg("argument declared %s is not a multirange type but type %s",
                               2530                 :                :                                     "anycompatiblemultirange",
                               2531                 :                :                                     format_type_be(anycompatible_multirange_typeid))));
                               2532                 :                :                 /* this enables element type matching check below */
  992 tgl@sss.pgh.pa.us        2533                 :CBC          33 :                 have_anycompatible_range = true;
                               2534                 :                :                 /* collect the subtype for common-supertype choice */
                               2535                 :             33 :                 anycompatible_actual_types[n_anycompatible_args++] =
                               2536                 :                :                     anycompatible_range_typelem;
                               2537                 :                :             }
                               2538                 :                :         }
                               2539   [ +  +  +  + ]:           1768 :         else if (have_anycompatible_multirange &&
                               2540                 :                :                  OidIsValid(anycompatible_range_typeid))
                               2541                 :                :         {
                               2542                 :              3 :             anycompatible_multirange_typeid = get_range_multirange(anycompatible_range_typeid);
                               2543                 :                :             /* We'll complain below if that didn't work */
                               2544                 :                :         }
                               2545                 :                : 
 1487                          2546         [ +  + ]:           1804 :         if (n_anycompatible_args > 0)
                               2547                 :                :         {
                               2548                 :                :             anycompatible_typeid =
                               2549                 :           1788 :                 select_common_type_from_oids(n_anycompatible_args,
                               2550                 :                :                                              anycompatible_actual_types,
                               2551                 :                :                                              false);
                               2552                 :                : 
                               2553                 :                :             /* We have to verify that the selected type actually works */
  806                          2554         [ -  + ]:           1788 :             if (!verify_common_type_from_oids(anycompatible_typeid,
                               2555                 :                :                                               n_anycompatible_args,
                               2556                 :                :                                               anycompatible_actual_types))
  806 tgl@sss.pgh.pa.us        2557         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2558                 :                :                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2559                 :                :                          errmsg("arguments of anycompatible family cannot be cast to a common type")));
                               2560                 :                : 
 1487 tgl@sss.pgh.pa.us        2561         [ +  + ]:CBC        1788 :             if (have_anycompatible_array)
                               2562                 :                :             {
                               2563                 :           1689 :                 anycompatible_array_typeid = get_array_type(anycompatible_typeid);
                               2564         [ -  + ]:           1689 :                 if (!OidIsValid(anycompatible_array_typeid))
 1487 tgl@sss.pgh.pa.us        2565         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2566                 :                :                             (errcode(ERRCODE_UNDEFINED_OBJECT),
                               2567                 :                :                              errmsg("could not find array type for data type %s",
                               2568                 :                :                                     format_type_be(anycompatible_typeid))));
                               2569                 :                :             }
                               2570                 :                : 
 1487 tgl@sss.pgh.pa.us        2571         [ +  + ]:CBC        1788 :             if (have_anycompatible_range)
                               2572                 :                :             {
                               2573                 :                :                 /* we can't infer a range type from the others */
                               2574         [ +  + ]:             96 :                 if (!OidIsValid(anycompatible_range_typeid))
                               2575         [ +  - ]:              3 :                     ereport(ERROR,
                               2576                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2577                 :                :                              errmsg("could not determine polymorphic type %s because input has type %s",
                               2578                 :                :                                     "anycompatiblerange", "unknown")));
                               2579                 :                : 
                               2580                 :                :                 /*
                               2581                 :                :                  * the anycompatible type must exactly match the range element
                               2582                 :                :                  * type
                               2583                 :                :                  */
                               2584         [ -  + ]:             93 :                 if (anycompatible_range_typelem != anycompatible_typeid)
 1487 tgl@sss.pgh.pa.us        2585         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2586                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2587                 :                :                              errmsg("anycompatiblerange type %s does not match anycompatible type %s",
                               2588                 :                :                                     format_type_be(anycompatible_range_typeid),
                               2589                 :                :                                     format_type_be(anycompatible_typeid))));
                               2590                 :                :             }
                               2591                 :                : 
  992 tgl@sss.pgh.pa.us        2592         [ +  + ]:CBC        1785 :             if (have_anycompatible_multirange)
                               2593                 :                :             {
                               2594                 :                :                 /* we can't infer a multirange type from the others */
                               2595         [ +  + ]:             42 :                 if (!OidIsValid(anycompatible_multirange_typeid))
                               2596         [ +  - ]:              3 :                     ereport(ERROR,
                               2597                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2598                 :                :                              errmsg("could not determine polymorphic type %s because input has type %s",
                               2599                 :                :                                     "anycompatiblemultirange", "unknown")));
                               2600                 :                : 
                               2601                 :                :                 /*
                               2602                 :                :                  * the anycompatible type must exactly match the multirange
                               2603                 :                :                  * element type
                               2604                 :                :                  */
                               2605         [ -  + ]:             39 :                 if (anycompatible_range_typelem != anycompatible_typeid)
  992 tgl@sss.pgh.pa.us        2606         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2607                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2608                 :                :                              errmsg("anycompatiblemultirange type %s does not match anycompatible type %s",
                               2609                 :                :                                     format_type_be(anycompatible_multirange_typeid),
                               2610                 :                :                                     format_type_be(anycompatible_typeid))));
                               2611                 :                :             }
                               2612                 :                : 
 1487 tgl@sss.pgh.pa.us        2613         [ +  + ]:CBC        1782 :             if (have_anycompatible_nonarray)
                               2614                 :                :             {
                               2615                 :                :                 /*
                               2616                 :                :                  * require the element type to not be an array or domain over
                               2617                 :                :                  * array
                               2618                 :                :                  */
                               2619         [ -  + ]:              6 :                 if (type_is_array_domain(anycompatible_typeid))
 1487 tgl@sss.pgh.pa.us        2620         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2621                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2622                 :                :                              errmsg("type matched to anycompatiblenonarray is an array type: %s",
                               2623                 :                :                                     format_type_be(anycompatible_typeid))));
                               2624                 :                :             }
                               2625                 :                :         }
                               2626                 :                :         else
                               2627                 :                :         {
 1487 tgl@sss.pgh.pa.us        2628         [ +  + ]:CBC          16 :             if (allow_poly)
                               2629                 :                :             {
                               2630                 :              4 :                 anycompatible_typeid = ANYCOMPATIBLEOID;
                               2631                 :              4 :                 anycompatible_array_typeid = ANYCOMPATIBLEARRAYOID;
                               2632                 :              4 :                 anycompatible_range_typeid = ANYCOMPATIBLERANGEOID;
 1211 akorotkov@postgresql     2633                 :              4 :                 anycompatible_multirange_typeid = ANYCOMPATIBLEMULTIRANGEOID;
                               2634                 :                :             }
                               2635                 :                :             else
                               2636                 :                :             {
                               2637                 :                :                 /*
                               2638                 :                :                  * Only way to get here is if all the family-2 polymorphic
                               2639                 :                :                  * arguments have UNKNOWN inputs.  Resolve to TEXT as
                               2640                 :                :                  * select_common_type() would do.  That doesn't license us to
                               2641                 :                :                  * use TEXTRANGE or TEXTMULTIRANGE, though.
                               2642                 :                :                  */
 1487 tgl@sss.pgh.pa.us        2643                 :             12 :                 anycompatible_typeid = TEXTOID;
                               2644                 :             12 :                 anycompatible_array_typeid = TEXTARRAYOID;
                               2645         [ +  + ]:             12 :                 if (have_anycompatible_range)
                               2646         [ +  - ]:              6 :                     ereport(ERROR,
                               2647                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2648                 :                :                              errmsg("could not determine polymorphic type %s because input has type %s",
                               2649                 :                :                                     "anycompatiblerange", "unknown")));
  992                          2650         [ +  + ]:              6 :                 if (have_anycompatible_multirange)
                               2651         [ +  - ]:              3 :                     ereport(ERROR,
                               2652                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2653                 :                :                              errmsg("could not determine polymorphic type %s because input has type %s",
                               2654                 :                :                                     "anycompatiblemultirange", "unknown")));
                               2655                 :                :             }
                               2656                 :                :         }
                               2657                 :                : 
                               2658                 :                :         /* replace family-2 polymorphic types by selected types */
 1487                          2659         [ +  + ]:           5424 :         for (int j = 0; j < nargs; j++)
                               2660                 :                :         {
                               2661                 :           3635 :             Oid         decl_type = declared_arg_types[j];
                               2662                 :                : 
                               2663   [ +  +  +  + ]:           3635 :             if (decl_type == ANYCOMPATIBLEOID ||
                               2664                 :                :                 decl_type == ANYCOMPATIBLENONARRAYOID)
                               2665                 :           1047 :                 declared_arg_types[j] = anycompatible_typeid;
                               2666         [ +  + ]:           2588 :             else if (decl_type == ANYCOMPATIBLEARRAYOID)
                               2667                 :           2417 :                 declared_arg_types[j] = anycompatible_array_typeid;
                               2668         [ +  + ]:            171 :             else if (decl_type == ANYCOMPATIBLERANGEOID)
                               2669                 :             63 :                 declared_arg_types[j] = anycompatible_range_typeid;
 1211 akorotkov@postgresql     2670         [ +  + ]:            108 :             else if (decl_type == ANYCOMPATIBLEMULTIRANGEOID)
                               2671                 :             39 :                 declared_arg_types[j] = anycompatible_multirange_typeid;
                               2672                 :                :         }
                               2673                 :                :     }
                               2674                 :                : 
                               2675                 :                :     /*
                               2676                 :                :      * If we had any UNKNOWN inputs for family-1 polymorphic arguments,
                               2677                 :                :      * re-scan to assign correct types to them.
                               2678                 :                :      *
                               2679                 :                :      * Note: we don't have to consider unknown inputs that were matched to
                               2680                 :                :      * family-2 polymorphic arguments, because we forcibly updated their
                               2681                 :                :      * declared_arg_types[] positions just above.
                               2682                 :                :      */
 1489 tgl@sss.pgh.pa.us        2683         [ +  + ]:          28326 :     if (have_poly_unknowns)
                               2684                 :                :     {
                               2685         [ +  + ]:           8518 :         for (int j = 0; j < nargs; j++)
                               2686                 :                :         {
 6157                          2687                 :           5825 :             Oid         decl_type = declared_arg_types[j];
 7559 bruce@momjian.us         2688                 :           5825 :             Oid         actual_type = actual_arg_types[j];
                               2689                 :                : 
 7677 tgl@sss.pgh.pa.us        2690         [ +  + ]:           5825 :             if (actual_type != UNKNOWNOID)
                               2691                 :           2807 :                 continue;
                               2692                 :                : 
 6157                          2693   [ +  +  +  + ]:           3018 :             if (decl_type == ANYELEMENTOID ||
                               2694         [ +  + ]:           2749 :                 decl_type == ANYNONARRAYOID ||
                               2695                 :                :                 decl_type == ANYENUMOID)
 7677                          2696                 :            357 :                 declared_arg_types[j] = elem_typeid;
 6157                          2697         [ +  + ]:           2661 :             else if (decl_type == ANYARRAYOID)
                               2698                 :                :             {
 7677                          2699         [ +  + ]:           1980 :                 if (!OidIsValid(array_typeid))
                               2700                 :                :                 {
                               2701                 :              9 :                     array_typeid = get_array_type(elem_typeid);
                               2702         [ -  + ]:              9 :                     if (!OidIsValid(array_typeid))
 7575 tgl@sss.pgh.pa.us        2703         [ #  # ]:UBC           0 :                         ereport(ERROR,
                               2704                 :                :                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                               2705                 :                :                                  errmsg("could not find array type for data type %s",
                               2706                 :                :                                         format_type_be(elem_typeid))));
                               2707                 :                :                 }
 7677 tgl@sss.pgh.pa.us        2708                 :CBC        1980 :                 declared_arg_types[j] = array_typeid;
                               2709                 :                :             }
 4546 heikki.linnakangas@i     2710         [ +  + ]:            681 :             else if (decl_type == ANYRANGEOID)
                               2711                 :                :             {
                               2712         [ -  + ]:            233 :                 if (!OidIsValid(range_typeid))
                               2713                 :                :                 {
                               2714                 :                :                     /* we can't infer a range type from the others */
 4546 heikki.linnakangas@i     2715         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2716                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2717                 :                :                              errmsg("could not determine polymorphic type %s because input has type %s",
                               2718                 :                :                                     "anyrange", "unknown")));
                               2719                 :                :                 }
 4546 heikki.linnakangas@i     2720                 :CBC         233 :                 declared_arg_types[j] = range_typeid;
                               2721                 :                :             }
 1211 akorotkov@postgresql     2722         [ +  + ]:            448 :             else if (decl_type == ANYMULTIRANGEOID)
                               2723                 :                :             {
                               2724         [ -  + ]:            126 :                 if (!OidIsValid(multirange_typeid))
                               2725                 :                :                 {
                               2726                 :                :                     /* we can't infer a multirange type from the others */
 1211 akorotkov@postgresql     2727         [ #  # ]:UBC           0 :                     ereport(ERROR,
                               2728                 :                :                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2729                 :                :                              errmsg("could not determine polymorphic type %s because input has type %s",
                               2730                 :                :                                     "anymultirange", "unknown")));
                               2731                 :                :                 }
 1211 akorotkov@postgresql     2732                 :CBC         126 :                 declared_arg_types[j] = multirange_typeid;
                               2733                 :                :             }
                               2734                 :                :         }
                               2735                 :                :     }
                               2736                 :                : 
                               2737                 :                :     /* if we return ANYELEMENT use the appropriate argument type */
 1489 tgl@sss.pgh.pa.us        2738   [ +  +  +  - ]:          28326 :     if (rettype == ANYELEMENTOID ||
                               2739         [ +  + ]:          23397 :         rettype == ANYNONARRAYOID ||
                               2740                 :                :         rettype == ANYENUMOID)
                               2741                 :           5043 :         return elem_typeid;
                               2742                 :                : 
                               2743                 :                :     /* if we return ANYARRAY use the appropriate argument type */
 7677                          2744         [ +  + ]:          23283 :     if (rettype == ANYARRAYOID)
                               2745                 :                :     {
                               2746         [ +  + ]:           7741 :         if (!OidIsValid(array_typeid))
                               2747                 :                :         {
 7599 bruce@momjian.us         2748                 :           7257 :             array_typeid = get_array_type(elem_typeid);
 7677 tgl@sss.pgh.pa.us        2749         [ -  + ]:           7257 :             if (!OidIsValid(array_typeid))
 7575 tgl@sss.pgh.pa.us        2750         [ #  # ]:UBC           0 :                 ereport(ERROR,
                               2751                 :                :                         (errcode(ERRCODE_UNDEFINED_OBJECT),
                               2752                 :                :                          errmsg("could not find array type for data type %s",
                               2753                 :                :                                 format_type_be(elem_typeid))));
                               2754                 :                :         }
 7677 tgl@sss.pgh.pa.us        2755                 :CBC        7741 :         return array_typeid;
                               2756                 :                :     }
                               2757                 :                : 
                               2758                 :                :     /* if we return ANYRANGE use the appropriate argument type */
 4546 heikki.linnakangas@i     2759         [ +  + ]:          15542 :     if (rettype == ANYRANGEOID)
                               2760                 :                :     {
                               2761                 :                :         /* this error is unreachable if the function signature is valid: */
                               2762         [ -  + ]:             94 :         if (!OidIsValid(range_typeid))
 4546 heikki.linnakangas@i     2763         [ #  # ]:UBC           0 :             ereport(ERROR,
                               2764                 :                :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2765                 :                :                      errmsg_internal("could not determine polymorphic type %s because input has type %s",
                               2766                 :                :                                      "anyrange", "unknown")));
 4546 heikki.linnakangas@i     2767                 :CBC          94 :         return range_typeid;
                               2768                 :                :     }
                               2769                 :                : 
                               2770                 :                :     /* if we return ANYMULTIRANGE use the appropriate argument type */
 1211 akorotkov@postgresql     2771         [ +  + ]:          15448 :     if (rettype == ANYMULTIRANGEOID)
                               2772                 :                :     {
                               2773                 :                :         /* this error is unreachable if the function signature is valid: */
                               2774         [ -  + ]:            406 :         if (!OidIsValid(multirange_typeid))
  992 tgl@sss.pgh.pa.us        2775         [ #  # ]:UBC           0 :             ereport(ERROR,
                               2776                 :                :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2777                 :                :                      errmsg_internal("could not determine polymorphic type %s because input has type %s",
                               2778                 :                :                                      "anymultirange", "unknown")));
 1211 akorotkov@postgresql     2779                 :CBC         406 :         return multirange_typeid;
                               2780                 :                :     }
                               2781                 :                : 
                               2782                 :                :     /* if we return ANYCOMPATIBLE use the appropriate type */
 1487 tgl@sss.pgh.pa.us        2783   [ +  +  -  + ]:          15042 :     if (rettype == ANYCOMPATIBLEOID ||
                               2784                 :                :         rettype == ANYCOMPATIBLENONARRAYOID)
                               2785                 :                :     {
                               2786                 :                :         /* this error is unreachable if the function signature is valid: */
                               2787         [ -  + ]:             79 :         if (!OidIsValid(anycompatible_typeid))
 1487 tgl@sss.pgh.pa.us        2788         [ #  # ]:UBC           0 :             ereport(ERROR,
                               2789                 :                :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2790                 :                :                      errmsg_internal("could not identify anycompatible type")));
 1487 tgl@sss.pgh.pa.us        2791                 :CBC          79 :         return anycompatible_typeid;
                               2792                 :                :     }
                               2793                 :                : 
                               2794                 :                :     /* if we return ANYCOMPATIBLEARRAY use the appropriate type */
                               2795         [ +  + ]:          14963 :     if (rettype == ANYCOMPATIBLEARRAYOID)
                               2796                 :                :     {
                               2797                 :                :         /* this error is unreachable if the function signature is valid: */
                               2798         [ -  + ]:           1521 :         if (!OidIsValid(anycompatible_array_typeid))
 1487 tgl@sss.pgh.pa.us        2799         [ #  # ]:UBC           0 :             ereport(ERROR,
                               2800                 :                :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2801                 :                :                      errmsg_internal("could not identify anycompatiblearray type")));
 1487 tgl@sss.pgh.pa.us        2802                 :CBC        1521 :         return anycompatible_array_typeid;
                               2803                 :                :     }
                               2804                 :                : 
                               2805                 :                :     /* if we return ANYCOMPATIBLERANGE use the appropriate argument type */
                               2806         [ +  + ]:          13442 :     if (rettype == ANYCOMPATIBLERANGEOID)
                               2807                 :                :     {
                               2808                 :                :         /* this error is unreachable if the function signature is valid: */
                               2809         [ -  + ]:             21 :         if (!OidIsValid(anycompatible_range_typeid))
 1487 tgl@sss.pgh.pa.us        2810         [ #  # ]:UBC           0 :             ereport(ERROR,
                               2811                 :                :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2812                 :                :                      errmsg_internal("could not identify anycompatiblerange type")));
 1487 tgl@sss.pgh.pa.us        2813                 :CBC          21 :         return anycompatible_range_typeid;
                               2814                 :                :     }
                               2815                 :                : 
                               2816                 :                :     /* if we return ANYCOMPATIBLEMULTIRANGE use the appropriate argument type */
 1211 akorotkov@postgresql     2817         [ +  + ]:          13421 :     if (rettype == ANYCOMPATIBLEMULTIRANGEOID)
                               2818                 :                :     {
                               2819                 :                :         /* this error is unreachable if the function signature is valid: */
                               2820         [ -  + ]:             15 :         if (!OidIsValid(anycompatible_multirange_typeid))
 1211 akorotkov@postgresql     2821         [ #  # ]:UBC           0 :             ereport(ERROR,
                               2822                 :                :                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                               2823                 :                :                      errmsg_internal("could not identify anycompatiblemultirange type")));
 1211 akorotkov@postgresql     2824                 :CBC          15 :         return anycompatible_multirange_typeid;
                               2825                 :                :     }
                               2826                 :                : 
                               2827                 :                :     /* we don't return a generic type; send back the original return type */
 7677 tgl@sss.pgh.pa.us        2828                 :          13406 :     return rettype;
                               2829                 :                : }
                               2830                 :                : 
                               2831                 :                : /*
                               2832                 :                :  * check_valid_polymorphic_signature()
                               2833                 :                :  *      Is a proposed function signature valid per polymorphism rules?
                               2834                 :                :  *
                               2835                 :                :  * Returns NULL if the signature is valid (either ret_type is not polymorphic,
                               2836                 :                :  * or it can be deduced from the given declared argument types).  Otherwise,
                               2837                 :                :  * returns a palloc'd, already translated errdetail string saying why not.
                               2838                 :                :  */
                               2839                 :                : char *
 1489                          2840                 :          16491 : check_valid_polymorphic_signature(Oid ret_type,
                               2841                 :                :                                   const Oid *declared_arg_types,
                               2842                 :                :                                   int nargs)
                               2843                 :                : {
 1211 akorotkov@postgresql     2844   [ +  +  +  + ]:          16491 :     if (ret_type == ANYRANGEOID || ret_type == ANYMULTIRANGEOID)
                               2845                 :                :     {
                               2846                 :                :         /*
                               2847                 :                :          * ANYRANGE and ANYMULTIRANGE require an ANYRANGE or ANYMULTIRANGE
                               2848                 :                :          * input, else we can't tell which of several range types with the
                               2849                 :                :          * same element type to use.
                               2850                 :                :          */
 1489 tgl@sss.pgh.pa.us        2851         [ +  + ]:            114 :         for (int i = 0; i < nargs; i++)
                               2852                 :                :         {
 1211 akorotkov@postgresql     2853         [ +  + ]:             78 :             if (declared_arg_types[i] == ANYRANGEOID ||
                               2854         [ +  + ]:             59 :                 declared_arg_types[i] == ANYMULTIRANGEOID)
 1489 tgl@sss.pgh.pa.us        2855                 :             38 :                 return NULL;    /* OK */
                               2856                 :                :         }
 1211 akorotkov@postgresql     2857                 :             36 :         return psprintf(_("A result of type %s requires at least one input of type anyrange or anymultirange."),
                               2858                 :                :                         format_type_be(ret_type));
                               2859                 :                :     }
                               2860   [ +  +  +  + ]:          16417 :     else if (ret_type == ANYCOMPATIBLERANGEOID || ret_type == ANYCOMPATIBLEMULTIRANGEOID)
                               2861                 :                :     {
                               2862                 :                :         /*
                               2863                 :                :          * ANYCOMPATIBLERANGE and ANYCOMPATIBLEMULTIRANGE require an
                               2864                 :                :          * ANYCOMPATIBLERANGE or ANYCOMPATIBLEMULTIRANGE input, else we can't
                               2865                 :                :          * tell which of several range types with the same element type to
                               2866                 :                :          * use.
                               2867                 :                :          */
                               2868         [ +  + ]:             72 :         for (int i = 0; i < nargs; i++)
                               2869                 :                :         {
                               2870         [ +  + ]:             51 :             if (declared_arg_types[i] == ANYCOMPATIBLERANGEOID ||
                               2871         [ +  + ]:             36 :                 declared_arg_types[i] == ANYCOMPATIBLEMULTIRANGEOID)
                               2872                 :             24 :                 return NULL;    /* OK */
                               2873                 :                :         }
                               2874                 :             21 :         return psprintf(_("A result of type %s requires at least one input of type anycompatiblerange or anycompatiblemultirange."),
                               2875                 :                :                         format_type_be(ret_type));
                               2876                 :                :     }
 1487 tgl@sss.pgh.pa.us        2877   [ +  +  +  +  :          16372 :     else if (IsPolymorphicTypeFamily1(ret_type))
                                     +  -  +  -  +  
                                           -  -  + ]
                               2878                 :                :     {
                               2879                 :                :         /* Otherwise, any family-1 type can be deduced from any other */
 1489                          2880         [ +  + ]:            578 :         for (int i = 0; i < nargs; i++)
                               2881                 :                :         {
 1487                          2882   [ +  +  +  +  :            521 :             if (IsPolymorphicTypeFamily1(declared_arg_types[i]))
                                     +  -  +  -  +  
                                           +  +  + ]
 1489                          2883                 :            470 :                 return NULL;    /* OK */
                               2884                 :                :         }
                               2885                 :                :         /* Keep this list in sync with IsPolymorphicTypeFamily1! */
 1211 akorotkov@postgresql     2886                 :             57 :         return psprintf(_("A result of type %s requires at least one input of type anyelement, anyarray, anynonarray, anyenum, anyrange, or anymultirange."),
                               2887                 :                :                         format_type_be(ret_type));
                               2888                 :                :     }
 1487 tgl@sss.pgh.pa.us        2889   [ +  +  +  +  :          15845 :     else if (IsPolymorphicTypeFamily2(ret_type))
                                     +  -  +  -  -  
                                                 + ]
                               2890                 :                :     {
                               2891                 :                :         /* Otherwise, any family-2 type can be deduced from any other */
                               2892         [ +  + ]:            118 :         for (int i = 0; i < nargs; i++)
                               2893                 :                :         {
                               2894   [ +  +  +  +  :            115 :             if (IsPolymorphicTypeFamily2(declared_arg_types[i]))
                                     +  +  +  +  +  
                                                 + ]
                               2895                 :             94 :                 return NULL;    /* OK */
                               2896                 :                :         }
                               2897                 :                :         /* Keep this list in sync with IsPolymorphicTypeFamily2! */
  992                          2898                 :              3 :         return psprintf(_("A result of type %s requires at least one input of type anycompatible, anycompatiblearray, anycompatiblenonarray, anycompatiblerange, or anycompatiblemultirange."),
                               2899                 :                :                         format_type_be(ret_type));
                               2900                 :                :     }
                               2901                 :                :     else
 1489                          2902                 :          15748 :         return NULL;            /* OK, ret_type is not polymorphic */
                               2903                 :                : }
                               2904                 :                : 
                               2905                 :                : /*
                               2906                 :                :  * check_valid_internal_signature()
                               2907                 :                :  *      Is a proposed function signature valid per INTERNAL safety rules?
                               2908                 :                :  *
                               2909                 :                :  * Returns NULL if OK, or a suitable error message if ret_type is INTERNAL but
                               2910                 :                :  * none of the declared arg types are.  (It's unsafe to create such a function
                               2911                 :                :  * since it would allow invocation of INTERNAL-consuming functions directly
                               2912                 :                :  * from SQL.)  It's overkill to return the error detail message, since there
                               2913                 :                :  * is only one possibility, but we do it like this to keep the API similar to
                               2914                 :                :  * check_valid_polymorphic_signature().
                               2915                 :                :  */
                               2916                 :                : char *
                               2917                 :          15964 : check_valid_internal_signature(Oid ret_type,
                               2918                 :                :                                const Oid *declared_arg_types,
                               2919                 :                :                                int nargs)
                               2920                 :                : {
                               2921         [ +  + ]:          15964 :     if (ret_type == INTERNALOID)
                               2922                 :                :     {
                               2923         [ +  - ]:            531 :         for (int i = 0; i < nargs; i++)
                               2924                 :                :         {
                               2925         [ +  + ]:            531 :             if (declared_arg_types[i] == ret_type)
                               2926                 :            378 :                 return NULL;    /* OK */
                               2927                 :                :         }
 1489 tgl@sss.pgh.pa.us        2928                 :UBC           0 :         return pstrdup(_("A result of type internal requires at least one input of type internal."));
                               2929                 :                :     }
                               2930                 :                :     else
 1489 tgl@sss.pgh.pa.us        2931                 :CBC       15586 :         return NULL;            /* OK, ret_type is not INTERNAL */
                               2932                 :                : }
                               2933                 :                : 
                               2934                 :                : 
                               2935                 :                : /* TypeCategory()
                               2936                 :                :  *      Assign a category to the specified type OID.
                               2937                 :                :  *
                               2938                 :                :  * NB: this must not return TYPCATEGORY_INVALID.
                               2939                 :                :  */
                               2940                 :                : TYPCATEGORY
 5737                          2941                 :          81472 : TypeCategory(Oid type)
                               2942                 :                : {
                               2943                 :                :     char        typcategory;
                               2944                 :                :     bool        typispreferred;
                               2945                 :                : 
                               2946                 :          81472 :     get_type_category_preferred(type, &typcategory, &typispreferred);
                               2947         [ -  + ]:          81472 :     Assert(typcategory != TYPCATEGORY_INVALID);
                               2948                 :          81472 :     return (TYPCATEGORY) typcategory;
                               2949                 :                : }
                               2950                 :                : 
                               2951                 :                : 
                               2952                 :                : /* IsPreferredType()
                               2953                 :                :  *      Check if this type is a preferred type for the given category.
                               2954                 :                :  *
                               2955                 :                :  * If category is TYPCATEGORY_INVALID, then we'll return true for preferred
                               2956                 :                :  * types of any category; otherwise, only for preferred types of that
                               2957                 :                :  * category.
                               2958                 :                :  */
                               2959                 :                : bool
                               2960                 :          13936 : IsPreferredType(TYPCATEGORY category, Oid type)
                               2961                 :                : {
                               2962                 :                :     char        typcategory;
                               2963                 :                :     bool        typispreferred;
                               2964                 :                : 
                               2965                 :          13936 :     get_type_category_preferred(type, &typcategory, &typispreferred);
                               2966   [ +  +  -  + ]:          13936 :     if (category == typcategory || category == TYPCATEGORY_INVALID)
                               2967                 :           9414 :         return typispreferred;
                               2968                 :                :     else
 7629                          2969                 :           4522 :         return false;
                               2970                 :                : }
                               2971                 :                : 
                               2972                 :                : 
                               2973                 :                : /* IsBinaryCoercible()
                               2974                 :                :  *      Check if srctype is binary-coercible to targettype.
                               2975                 :                :  *
                               2976                 :                :  * This notion allows us to cheat and directly exchange values without
                               2977                 :                :  * going through the trouble of calling a conversion function.  Note that
                               2978                 :                :  * in general, this should only be an implementation shortcut.  Before 7.4,
                               2979                 :                :  * this was also used as a heuristic for resolving overloaded functions and
                               2980                 :                :  * operators, but that's basically a bad idea.
                               2981                 :                :  *
                               2982                 :                :  * As of 7.3, binary coercibility isn't hardwired into the code anymore.
                               2983                 :                :  * We consider two types binary-coercible if there is an implicitly
                               2984                 :                :  * invokable, no-function-needed pg_cast entry.  Also, a domain is always
                               2985                 :                :  * binary-coercible to its base type, though *not* vice versa (in the other
                               2986                 :                :  * direction, one must apply domain constraint checks before accepting the
                               2987                 :                :  * value as legitimate).  We also need to special-case various polymorphic
                               2988                 :                :  * types.
                               2989                 :                :  *
                               2990                 :                :  * This function replaces IsBinaryCompatible(), which was an inherently
                               2991                 :                :  * symmetric test.  Since the pg_cast entries aren't necessarily symmetric,
                               2992                 :                :  * the order of the operands is now significant.
                               2993                 :                :  */
                               2994                 :                : bool
 7879                          2995                 :        1096260 : IsBinaryCoercible(Oid srctype, Oid targettype)
                               2996                 :                : {
                               2997                 :                :     Oid         castoid;
                               2998                 :                : 
  545                          2999                 :        1096260 :     return IsBinaryCoercibleWithCast(srctype, targettype, &castoid);
                               3000                 :                : }
                               3001                 :                : 
                               3002                 :                : /* IsBinaryCoercibleWithCast()
                               3003                 :                :  *      Check if srctype is binary-coercible to targettype.
                               3004                 :                :  *
                               3005                 :                :  * This variant also returns the OID of the pg_cast entry if one is involved.
                               3006                 :                :  * *castoid is set to InvalidOid if no binary-coercible cast exists, or if
                               3007                 :                :  * there is a hard-wired rule for it rather than a pg_cast entry.
                               3008                 :                :  */
                               3009                 :                : bool
                               3010                 :        1096356 : IsBinaryCoercibleWithCast(Oid srctype, Oid targettype,
                               3011                 :                :                           Oid *castoid)
                               3012                 :                : {
                               3013                 :                :     HeapTuple   tuple;
                               3014                 :                :     Form_pg_cast castForm;
                               3015                 :                :     bool        result;
                               3016                 :                : 
                               3017                 :        1096356 :     *castoid = InvalidOid;
                               3018                 :                : 
                               3019                 :                :     /* Fast path if same type */
 7879                          3020         [ +  + ]:        1096356 :     if (srctype == targettype)
 7896                          3021                 :         248176 :         return true;
                               3022                 :                : 
                               3023                 :                :     /* Anything is coercible to ANY or ANYELEMENT or ANYCOMPATIBLE */
 1487                          3024   [ +  +  +  +  :         848180 :     if (targettype == ANYOID || targettype == ANYELEMENTOID ||
                                              -  + ]
                               3025                 :                :         targettype == ANYCOMPATIBLEOID)
 3765                          3026                 :             94 :         return true;
                               3027                 :                : 
                               3028                 :                :     /* If srctype is a domain, reduce to its base type */
 7879                          3029         [ +  - ]:         848086 :     if (OidIsValid(srctype))
                               3030                 :         848086 :         srctype = getBaseType(srctype);
                               3031                 :                : 
                               3032                 :                :     /* Somewhat-fast path for domain -> base type case */
                               3033         [ +  + ]:         848086 :     if (srctype == targettype)
 7896                          3034                 :              6 :         return true;
                               3035                 :                : 
                               3036                 :                :     /* Also accept any array type as coercible to ANY[COMPATIBLE]ARRAY */
 1487                          3037   [ +  +  -  + ]:         848080 :     if (targettype == ANYARRAYOID || targettype == ANYCOMPATIBLEARRAYOID)
 4529                          3038         [ +  + ]:          45234 :         if (type_is_array(srctype))
 6157                          3039                 :           2004 :             return true;
                               3040                 :                : 
                               3041                 :                :     /* Also accept any non-array type as coercible to ANY[COMPATIBLE]NONARRAY */
 1487                          3042   [ +  -  -  + ]:         846076 :     if (targettype == ANYNONARRAYOID || targettype == ANYCOMPATIBLENONARRAYOID)
 4529 tgl@sss.pgh.pa.us        3043         [ #  # ]:UBC           0 :         if (!type_is_array(srctype))
 7597                          3044                 :              0 :             return true;
                               3045                 :                : 
                               3046                 :                :     /* Also accept any enum type as coercible to ANYENUM */
 6222 tgl@sss.pgh.pa.us        3047         [ +  + ]:CBC      846076 :     if (targettype == ANYENUMOID)
                               3048         [ +  + ]:          41988 :         if (type_is_enum(srctype))
                               3049                 :             80 :             return true;
                               3050                 :                : 
                               3051                 :                :     /* Also accept any range type as coercible to ANY[COMPATIBLE]RANGE */
 1487                          3052   [ +  +  -  + ]:         845996 :     if (targettype == ANYRANGEOID || targettype == ANYCOMPATIBLERANGEOID)
 4546 heikki.linnakangas@i     3053         [ +  + ]:          11045 :         if (type_is_range(srctype))
                               3054                 :           1464 :             return true;
                               3055                 :                : 
                               3056                 :                :     /* Also, any multirange type is coercible to ANY[COMPATIBLE]MULTIRANGE */
 1211 akorotkov@postgresql     3057   [ +  +  -  + ]:         844532 :     if (targettype == ANYMULTIRANGEOID || targettype == ANYCOMPATIBLEMULTIRANGEOID)
                               3058         [ +  + ]:          23482 :         if (type_is_multirange(srctype))
                               3059                 :            126 :             return true;
                               3060                 :                : 
                               3061                 :                :     /* Also accept any composite type as coercible to RECORD */
 5662 tgl@sss.pgh.pa.us        3062         [ +  + ]:         844406 :     if (targettype == RECORDOID)
                               3063         [ +  + ]:           9382 :         if (ISCOMPLEX(srctype))
                               3064                 :            382 :             return true;
                               3065                 :                : 
                               3066                 :                :     /* Also accept any composite array type as coercible to RECORD[] */
                               3067         [ -  + ]:         844024 :     if (targettype == RECORDARRAYOID)
 5662 tgl@sss.pgh.pa.us        3068         [ #  # ]:UBC           0 :         if (is_complex_array(srctype))
                               3069                 :              0 :             return true;
                               3070                 :                : 
                               3071                 :                :     /* Else look in pg_cast */
 5173 rhaas@postgresql.org     3072                 :CBC      844024 :     tuple = SearchSysCache2(CASTSOURCETARGET,
                               3073                 :                :                             ObjectIdGetDatum(srctype),
                               3074                 :                :                             ObjectIdGetDatum(targettype));
 7896 tgl@sss.pgh.pa.us        3075         [ +  + ]:         844024 :     if (!HeapTupleIsValid(tuple))
                               3076                 :         693025 :         return false;           /* no cast */
                               3077                 :         150999 :     castForm = (Form_pg_cast) GETSTRUCT(tuple);
                               3078                 :                : 
 5155 heikki.linnakangas@i     3079         [ +  + ]:         167624 :     result = (castForm->castmethod == COERCION_METHOD_BINARY &&
 7879 tgl@sss.pgh.pa.us        3080         [ +  + ]:          16625 :               castForm->castcontext == COERCION_CODE_IMPLICIT);
                               3081                 :                : 
  545                          3082         [ +  + ]:         150999 :     if (result)
                               3083                 :           7009 :         *castoid = castForm->oid;
                               3084                 :                : 
 7896                          3085                 :         150999 :     ReleaseSysCache(tuple);
                               3086                 :                : 
                               3087                 :         150999 :     return result;
                               3088                 :                : }
                               3089                 :                : 
                               3090                 :                : 
                               3091                 :                : /*
                               3092                 :                :  * find_coercion_pathway
                               3093                 :                :  *      Look for a coercion pathway between two types.
                               3094                 :                :  *
                               3095                 :                :  * Currently, this deals only with scalar-type cases; it does not consider
                               3096                 :                :  * polymorphic types nor casts between composite types.  (Perhaps fold
                               3097                 :                :  * those in someday?)
                               3098                 :                :  *
                               3099                 :                :  * ccontext determines the set of available casts.
                               3100                 :                :  *
                               3101                 :                :  * The possible result codes are:
                               3102                 :                :  *  COERCION_PATH_NONE: failed to find any coercion pathway
                               3103                 :                :  *              *funcid is set to InvalidOid
                               3104                 :                :  *  COERCION_PATH_FUNC: apply the coercion function returned in *funcid
                               3105                 :                :  *  COERCION_PATH_RELABELTYPE: binary-compatible cast, no function needed
                               3106                 :                :  *              *funcid is set to InvalidOid
                               3107                 :                :  *  COERCION_PATH_ARRAYCOERCE: need an ArrayCoerceExpr node
                               3108                 :                :  *              *funcid is set to InvalidOid
                               3109                 :                :  *  COERCION_PATH_COERCEVIAIO: need a CoerceViaIO node
                               3110                 :                :  *              *funcid is set to InvalidOid
                               3111                 :                :  *
                               3112                 :                :  * Note: COERCION_PATH_RELABELTYPE does not necessarily mean that no work is
                               3113                 :                :  * needed to do the coercion; if the target is a domain then we may need to
                               3114                 :                :  * apply domain constraint checking.  If you want to check for a zero-effort
                               3115                 :                :  * conversion then use IsBinaryCoercible().
                               3116                 :                :  */
                               3117                 :                : CoercionPathType
 7879                          3118                 :         573346 : find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId,
                               3119                 :                :                       CoercionContext ccontext,
                               3120                 :                :                       Oid *funcid)
                               3121                 :                : {
 6158                          3122                 :         573346 :     CoercionPathType result = COERCION_PATH_NONE;
                               3123                 :                :     HeapTuple   tuple;
                               3124                 :                : 
 7896                          3125                 :         573346 :     *funcid = InvalidOid;
                               3126                 :                : 
                               3127                 :                :     /* Perhaps the types are domains; if so, look at their base types */
                               3128         [ +  - ]:         573346 :     if (OidIsValid(sourceTypeId))
                               3129                 :         573346 :         sourceTypeId = getBaseType(sourceTypeId);
                               3130         [ +  - ]:         573346 :     if (OidIsValid(targetTypeId))
                               3131                 :         573346 :         targetTypeId = getBaseType(targetTypeId);
                               3132                 :                : 
                               3133                 :                :     /* Domains are always coercible to and from their base type */
                               3134         [ +  + ]:         573346 :     if (sourceTypeId == targetTypeId)
 6158                          3135                 :          36975 :         return COERCION_PATH_RELABELTYPE;
                               3136                 :                : 
                               3137                 :                :     /* Look in pg_cast */
 5173 rhaas@postgresql.org     3138                 :         536371 :     tuple = SearchSysCache2(CASTSOURCETARGET,
                               3139                 :                :                             ObjectIdGetDatum(sourceTypeId),
                               3140                 :                :                             ObjectIdGetDatum(targetTypeId));
                               3141                 :                : 
 7941 peter_e@gmx.net          3142         [ +  + ]:         536371 :     if (HeapTupleIsValid(tuple))
                               3143                 :                :     {
 7896 tgl@sss.pgh.pa.us        3144                 :         205687 :         Form_pg_cast castForm = (Form_pg_cast) GETSTRUCT(tuple);
                               3145                 :                :         CoercionContext castcontext;
                               3146                 :                : 
                               3147                 :                :         /* convert char value for castcontext to CoercionContext enum */
 7879                          3148   [ +  +  +  - ]:         205687 :         switch (castForm->castcontext)
                               3149                 :                :         {
                               3150                 :         162779 :             case COERCION_CODE_IMPLICIT:
                               3151                 :         162779 :                 castcontext = COERCION_IMPLICIT;
                               3152                 :         162779 :                 break;
                               3153                 :          38901 :             case COERCION_CODE_ASSIGNMENT:
                               3154                 :          38901 :                 castcontext = COERCION_ASSIGNMENT;
                               3155                 :          38901 :                 break;
                               3156                 :           4007 :             case COERCION_CODE_EXPLICIT:
                               3157                 :           4007 :                 castcontext = COERCION_EXPLICIT;
                               3158                 :           4007 :                 break;
 7879 tgl@sss.pgh.pa.us        3159                 :UBC           0 :             default:
 7575                          3160         [ #  # ]:              0 :                 elog(ERROR, "unrecognized castcontext: %d",
                               3161                 :                :                      (int) castForm->castcontext);
                               3162                 :                :                 castcontext = 0;    /* keep compiler quiet */
                               3163                 :                :                 break;
                               3164                 :                :         }
                               3165                 :                : 
                               3166                 :                :         /* Rely on ordering of enum for correct behavior here */
 7879 tgl@sss.pgh.pa.us        3167         [ +  + ]:CBC      205687 :         if (ccontext >= castcontext)
                               3168                 :                :         {
 5644 heikki.linnakangas@i     3169   [ +  +  +  - ]:         172181 :             switch (castForm->castmethod)
                               3170                 :                :             {
                               3171                 :          69535 :                 case COERCION_METHOD_FUNCTION:
                               3172                 :          69535 :                     result = COERCION_PATH_FUNC;
                               3173                 :          69535 :                     *funcid = castForm->castfunc;
                               3174                 :          69535 :                     break;
                               3175                 :            364 :                 case COERCION_METHOD_INOUT:
                               3176                 :            364 :                     result = COERCION_PATH_COERCEVIAIO;
                               3177                 :            364 :                     break;
                               3178                 :         102282 :                 case COERCION_METHOD_BINARY:
                               3179                 :         102282 :                     result = COERCION_PATH_RELABELTYPE;
                               3180                 :         102282 :                     break;
 5644 heikki.linnakangas@i     3181                 :UBC           0 :                 default:
                               3182         [ #  # ]:              0 :                     elog(ERROR, "unrecognized castmethod: %d",
                               3183                 :                :                          (int) castForm->castmethod);
                               3184                 :                :                     break;
                               3185                 :                :             }
                               3186                 :                :         }
                               3187                 :                : 
 7941 peter_e@gmx.net          3188                 :CBC      205687 :         ReleaseSysCache(tuple);
                               3189                 :                :     }
                               3190                 :                :     else
                               3191                 :                :     {
                               3192                 :                :         /*
                               3193                 :                :          * If there's no pg_cast entry, perhaps we are dealing with a pair of
                               3194                 :                :          * array types.  If so, and if their element types have a conversion
                               3195                 :                :          * pathway, report that we can coerce with an ArrayCoerceExpr.
                               3196                 :                :          *
                               3197                 :                :          * Hack: disallow coercions to oidvector and int2vector, which
                               3198                 :                :          * otherwise tend to capture coercions that should go to "real" array
                               3199                 :                :          * types.  We want those types to be considered "real" arrays for many
                               3200                 :                :          * purposes, but not this one.  (Also, ArrayCoerceExpr isn't
                               3201                 :                :          * guaranteed to produce an output that meets the restrictions of
                               3202                 :                :          * these datatypes, such as being 1-dimensional.)
                               3203                 :                :          */
 6158 tgl@sss.pgh.pa.us        3204   [ +  +  +  - ]:         330684 :         if (targetTypeId != OIDVECTOROID && targetTypeId != INT2VECTOROID)
                               3205                 :                :         {
                               3206                 :                :             Oid         targetElem;
                               3207                 :                :             Oid         sourceElem;
                               3208                 :                : 
                               3209   [ +  +  +  + ]:         330777 :             if ((targetElem = get_element_type(targetTypeId)) != InvalidOid &&
 2388                          3210                 :           5139 :                 (sourceElem = get_element_type(sourceTypeId)) != InvalidOid)
                               3211                 :                :             {
                               3212                 :                :                 CoercionPathType elempathtype;
                               3213                 :                :                 Oid         elemfuncid;
                               3214                 :                : 
 6158                          3215                 :           4571 :                 elempathtype = find_coercion_pathway(targetElem,
                               3216                 :                :                                                      sourceElem,
                               3217                 :                :                                                      ccontext,
                               3218                 :                :                                                      &elemfuncid);
 2388                          3219         [ +  + ]:           4571 :                 if (elempathtype != COERCION_PATH_NONE)
                               3220                 :                :                 {
                               3221                 :           4335 :                     result = COERCION_PATH_ARRAYCOERCE;
                               3222                 :                :                 }
                               3223                 :                :             }
                               3224                 :                :         }
                               3225                 :                : 
                               3226                 :                :         /*
                               3227                 :                :          * If we still haven't found a possibility, consider automatic casting
                               3228                 :                :          * using I/O functions.  We allow assignment casts to string types and
                               3229                 :                :          * explicit casts from string types to be handled this way. (The
                               3230                 :                :          * CoerceViaIO mechanism is a lot more general than that, but this is
                               3231                 :                :          * all we want to allow in the absence of a pg_cast entry.) It would
                               3232                 :                :          * probably be better to insist on explicit casts in both directions,
                               3233                 :                :          * but this is a compromise to preserve something of the pre-8.3
                               3234                 :                :          * behavior that many types had implicit (yipes!) casts to text.
                               3235                 :                :          */
 6158                          3236         [ +  + ]:         330684 :         if (result == COERCION_PATH_NONE)
                               3237                 :                :         {
                               3238   [ +  +  +  + ]:         348949 :             if (ccontext >= COERCION_ASSIGNMENT &&
 5737                          3239                 :          22600 :                 TypeCategory(targetTypeId) == TYPCATEGORY_STRING)
 6158                          3240                 :          17823 :                 result = COERCION_PATH_COERCEVIAIO;
                               3241   [ +  +  +  + ]:         312842 :             else if (ccontext >= COERCION_EXPLICIT &&
 5737                          3242                 :           4316 :                      TypeCategory(sourceTypeId) == TYPCATEGORY_STRING)
 6158                          3243                 :           2586 :                 result = COERCION_PATH_COERCEVIAIO;
                               3244                 :                :         }
                               3245                 :                :     }
                               3246                 :                : 
                               3247                 :                :     /*
                               3248                 :                :      * When parsing PL/pgSQL assignments, allow an I/O cast to be used
                               3249                 :                :      * whenever no normal coercion is available.
                               3250                 :                :      */
 1196                          3251   [ +  +  +  + ]:         536371 :     if (result == COERCION_PATH_NONE &&
                               3252                 :                :         ccontext == COERCION_PLPGSQL)
                               3253                 :            110 :         result = COERCION_PATH_COERCEVIAIO;
                               3254                 :                : 
 7896                          3255                 :         536371 :     return result;
                               3256                 :                : }
                               3257                 :                : 
                               3258                 :                : 
                               3259                 :                : /*
                               3260                 :                :  * find_typmod_coercion_function -- does the given type need length coercion?
                               3261                 :                :  *
                               3262                 :                :  * If the target type possesses a pg_cast function from itself to itself,
                               3263                 :                :  * it must need length coercion.
                               3264                 :                :  *
                               3265                 :                :  * "bpchar" (ie, char(N)) and "numeric" are examples of such types.
                               3266                 :                :  *
                               3267                 :                :  * If the given type is a varlena array type, we do not look for a coercion
                               3268                 :                :  * function associated directly with the array type, but instead look for
                               3269                 :                :  * one associated with the element type.  An ArrayCoerceExpr node must be
                               3270                 :                :  * used to apply such a function.  (Note: currently, it's pointless to
                               3271                 :                :  * return the funcid in this case, because it'll just get looked up again
                               3272                 :                :  * in the recursive construction of the ArrayCoerceExpr's elemexpr.)
                               3273                 :                :  *
                               3274                 :                :  * We use the same result enum as find_coercion_pathway, but the only possible
                               3275                 :                :  * result codes are:
                               3276                 :                :  *  COERCION_PATH_NONE: no length coercion needed
                               3277                 :                :  *  COERCION_PATH_FUNC: apply the function returned in *funcid
                               3278                 :                :  *  COERCION_PATH_ARRAYCOERCE: apply the function using ArrayCoerceExpr
                               3279                 :                :  */
                               3280                 :                : CoercionPathType
 6228                          3281                 :          10033 : find_typmod_coercion_function(Oid typeId,
                               3282                 :                :                               Oid *funcid)
                               3283                 :                : {
                               3284                 :                :     CoercionPathType result;
                               3285                 :                :     Type        targetType;
                               3286                 :                :     Form_pg_type typeForm;
                               3287                 :                :     HeapTuple   tuple;
                               3288                 :                : 
                               3289                 :          10033 :     *funcid = InvalidOid;
 6158                          3290                 :          10033 :     result = COERCION_PATH_FUNC;
                               3291                 :                : 
 7941 peter_e@gmx.net          3292                 :          10033 :     targetType = typeidType(typeId);
 7879 tgl@sss.pgh.pa.us        3293                 :          10033 :     typeForm = (Form_pg_type) GETSTRUCT(targetType);
                               3294                 :                : 
                               3295                 :                :     /* Check for a "true" array type */
 1222                          3296   [ +  +  +  - ]:          10033 :     if (IsTrueArrayType(typeForm))
                               3297                 :                :     {
                               3298                 :                :         /* Yes, switch our attention to the element type */
 7879                          3299                 :             42 :         typeId = typeForm->typelem;
 6158                          3300                 :             42 :         result = COERCION_PATH_ARRAYCOERCE;
                               3301                 :                :     }
 7242                          3302                 :          10033 :     ReleaseSysCache(targetType);
                               3303                 :                : 
                               3304                 :                :     /* Look in pg_cast */
 5173 rhaas@postgresql.org     3305                 :          10033 :     tuple = SearchSysCache2(CASTSOURCETARGET,
                               3306                 :                :                             ObjectIdGetDatum(typeId),
                               3307                 :                :                             ObjectIdGetDatum(typeId));
                               3308                 :                : 
 7242 tgl@sss.pgh.pa.us        3309         [ +  + ]:          10033 :     if (HeapTupleIsValid(tuple))
                               3310                 :                :     {
                               3311                 :          10027 :         Form_pg_cast castForm = (Form_pg_cast) GETSTRUCT(tuple);
                               3312                 :                : 
 6228                          3313                 :          10027 :         *funcid = castForm->castfunc;
 7242                          3314                 :          10027 :         ReleaseSysCache(tuple);
                               3315                 :                :     }
                               3316                 :                : 
 6158                          3317         [ +  + ]:          10033 :     if (!OidIsValid(*funcid))
                               3318                 :              6 :         result = COERCION_PATH_NONE;
                               3319                 :                : 
                               3320                 :          10033 :     return result;
                               3321                 :                : }
                               3322                 :                : 
                               3323                 :                : /*
                               3324                 :                :  * is_complex_array
                               3325                 :                :  *      Is this type an array of composite?
                               3326                 :                :  *
                               3327                 :                :  * Note: this will not return true for record[]; check for RECORDARRAYOID
                               3328                 :                :  * separately if needed.
                               3329                 :                :  */
                               3330                 :                : static bool
 5662                          3331                 :             14 : is_complex_array(Oid typid)
                               3332                 :                : {
                               3333                 :             14 :     Oid         elemtype = get_element_type(typid);
                               3334                 :                : 
                               3335   [ +  +  +  - ]:             14 :     return (OidIsValid(elemtype) && ISCOMPLEX(elemtype));
                               3336                 :                : }
                               3337                 :                : 
                               3338                 :                : 
                               3339                 :                : /*
                               3340                 :                :  * Check whether reltypeId is the row type of a typed table of type
                               3341                 :                :  * reloftypeId, or is a domain over such a row type.  (This is conceptually
                               3342                 :                :  * similar to the subtype relationship checked by typeInheritsFrom().)
                               3343                 :                :  */
                               3344                 :                : static bool
 4852 peter_e@gmx.net          3345                 :         335937 : typeIsOfTypedTable(Oid reltypeId, Oid reloftypeId)
                               3346                 :                : {
 2362 tgl@sss.pgh.pa.us        3347                 :         335937 :     Oid         relid = typeOrDomainTypeRelid(reltypeId);
 4753 bruce@momjian.us         3348                 :         335937 :     bool        result = false;
                               3349                 :                : 
 4852 peter_e@gmx.net          3350         [ +  + ]:         335937 :     if (relid)
                               3351                 :                :     {
                               3352                 :                :         HeapTuple   tp;
                               3353                 :                :         Form_pg_class reltup;
                               3354                 :                : 
                               3355                 :           6096 :         tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
                               3356         [ -  + ]:           6096 :         if (!HeapTupleIsValid(tp))
 4852 peter_e@gmx.net          3357         [ #  # ]:UBC           0 :             elog(ERROR, "cache lookup failed for relation %u", relid);
                               3358                 :                : 
 4852 peter_e@gmx.net          3359                 :CBC        6096 :         reltup = (Form_pg_class) GETSTRUCT(tp);
                               3360         [ +  + ]:           6096 :         if (reltup->reloftype == reloftypeId)
                               3361                 :              6 :             result = true;
                               3362                 :                : 
                               3363                 :           6096 :         ReleaseSysCache(tp);
                               3364                 :                :     }
                               3365                 :                : 
                               3366                 :         335937 :     return result;
                               3367                 :                : }
        

Generated by: LCOV version 2.1-beta2-3-g6141622