parse_coerce.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "catalog/pg_cast.h"
#include "catalog/pg_class.h"
#include "catalog/pg_inherits.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_coerce.h"
#include "parser/parse_relation.h"
#include "parser/parse_type.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

Include dependency graph for parse_coerce.c:

Go to the source code of this file.

Functions
static Node *	coerce_type_typmod (Node *node, Oid targetTypeId, int32 targetTypMod, CoercionContext ccontext, CoercionForm cformat, int location, bool hideInputCoercion)
static void	hide_coercion_node (Node *node)
static Node *	build_coercion_expression (Node *node, CoercionPathType pathtype, Oid funcId, Oid targetTypeId, int32 targetTypMod, CoercionContext ccontext, CoercionForm cformat, int location)
static Node *	coerce_record_to_complex (ParseState *pstate, Node *node, Oid targetTypeId, CoercionContext ccontext, CoercionForm cformat, int location)
static bool	is_complex_array (Oid typid)
static bool	typeIsOfTypedTable (Oid reltypeId, Oid reloftypeId)
Node *	coerce_to_target_type (ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)
Node *	coerce_type (ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId, int32 targetTypeMod, CoercionContext ccontext, CoercionForm cformat, int location)
bool	can_coerce_type (int nargs, const Oid *input_typeids, const Oid *target_typeids, CoercionContext ccontext)
Node *	coerce_to_domain (Node *arg, Oid baseTypeId, int32 baseTypeMod, Oid typeId, CoercionContext ccontext, CoercionForm cformat, int location, bool hideInputCoercion)
Node *	coerce_to_boolean (ParseState *pstate, Node *node, const char *constructName)
Node *	coerce_to_specific_type_typmod (ParseState *pstate, Node *node, Oid targetTypeId, int32 targetTypmod, const char *constructName)
Node *	coerce_to_specific_type (ParseState *pstate, Node *node, Oid targetTypeId, const char *constructName)
Node *	coerce_null_to_domain (Oid typid, int32 typmod, Oid collation, int typlen, bool typbyval)
int	parser_coercion_errposition (ParseState *pstate, int coerce_location, Node *input_expr)
Oid	select_common_type (ParseState *pstate, List *exprs, const char *context, Node **which_expr)
static Oid	select_common_type_from_oids (int nargs, const Oid *typeids, bool noerror)
Node *	coerce_to_common_type (ParseState *pstate, Node *node, Oid targetTypeId, const char *context)
bool	verify_common_type (Oid common_type, List *exprs)
static bool	verify_common_type_from_oids (Oid common_type, int nargs, const Oid *typeids)
int32	select_common_typmod (ParseState *pstate, List *exprs, Oid common_type)
bool	check_generic_type_consistency (const Oid *actual_arg_types, const Oid *declared_arg_types, int nargs)
Oid	enforce_generic_type_consistency (const Oid *actual_arg_types, Oid *declared_arg_types, int nargs, Oid rettype, bool allow_poly)
char *	check_valid_polymorphic_signature (Oid ret_type, const Oid *declared_arg_types, int nargs)
char *	check_valid_internal_signature (Oid ret_type, const Oid *declared_arg_types, int nargs)
TYPCATEGORY	TypeCategory (Oid type)
bool	IsPreferredType (TYPCATEGORY category, Oid type)
bool	IsBinaryCoercible (Oid srctype, Oid targettype)
bool	IsBinaryCoercibleWithCast (Oid srctype, Oid targettype, Oid *castoid)
CoercionPathType	find_coercion_pathway (Oid targetTypeId, Oid sourceTypeId, CoercionContext ccontext, Oid *funcid)
CoercionPathType	find_typmod_coercion_function (Oid typeId, Oid *funcid)

Function Documentation

build_coercion_expression()

static Node * build_coercion_expression ( Node *  node, CoercionPathType  pathtype, Oid  funcId, Oid  targetTypeId, int32  targetTypMod, CoercionContext  ccontext, CoercionForm  cformat, int  location  )

static

Definition at line 838 of file parse_coerce.c.

{
    int         nargs = 0;
 
    if (OidIsValid(funcId))
    {
        HeapTuple   tp;
        Form_pg_proc procstruct;
 
        tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcId));
        if (!HeapTupleIsValid(tp))
            elog(ERROR, "cache lookup failed for function %u", funcId);
        procstruct = (Form_pg_proc) GETSTRUCT(tp);
 
        /*
         * These Asserts essentially check that function is a legal coercion
         * function.  We can't make the seemingly obvious tests on prorettype
         * and proargtypes[0], even in the COERCION_PATH_FUNC case, because of
         * various binary-compatibility cases.
         */
        /* Assert(targetTypeId == procstruct->prorettype); */
        Assert(!procstruct->proretset);
        Assert(procstruct->prokind == PROKIND_FUNCTION);
        nargs = procstruct->pronargs;
        Assert(nargs >= 1 && nargs <= 3);
        /* Assert(procstruct->proargtypes.values[0] == exprType(node)); */
        Assert(nargs < 2 || procstruct->proargtypes.values[1] == INT4OID);
        Assert(nargs < 3 || procstruct->proargtypes.values[2] == BOOLOID);
 
        ReleaseSysCache(tp);
    }
 
    if (pathtype == COERCION_PATH_FUNC)
    {
        /* We build an ordinary FuncExpr with special arguments */
        FuncExpr   *fexpr;
        List       *args;
        Const      *cons;
 
        Assert(OidIsValid(funcId));
 
        args = list_make1(node);
 
        if (nargs >= 2)
        {
            /* Pass target typmod as an int4 constant */
            cons = makeConst(INT4OID,
                             -1,
                             InvalidOid,
                             sizeof(int32),
                             Int32GetDatum(targetTypMod),
                             false,
                             true);
 
            args = lappend(args, cons);
        }
 
        if (nargs == 3)
        {
            /* Pass it a boolean isExplicit parameter, too */
            cons = makeConst(BOOLOID,
                             -1,
                             InvalidOid,
                             sizeof(bool),
                             BoolGetDatum(ccontext == COERCION_EXPLICIT),
                             false,
                             true);
 
            args = lappend(args, cons);
        }
 
        fexpr = makeFuncExpr(funcId, targetTypeId, args,
                             InvalidOid, InvalidOid, cformat);
        fexpr->location = location;
        return (Node *) fexpr;
    }
    else if (pathtype == COERCION_PATH_ARRAYCOERCE)
    {
        /* We need to build an ArrayCoerceExpr */
        ArrayCoerceExpr *acoerce = makeNode(ArrayCoerceExpr);
        CaseTestExpr *ctest = makeNode(CaseTestExpr);
        Oid         sourceBaseTypeId;
        int32       sourceBaseTypeMod;
        Oid         targetElementType;
        Node       *elemexpr;
 
        /*
         * Look through any domain over the source array type.  Note we don't
         * expect that the target type is a domain; it must be a plain array.
         * (To get to a domain target type, we'll do coerce_to_domain later.)
         */
        sourceBaseTypeMod = exprTypmod(node);
        sourceBaseTypeId = getBaseTypeAndTypmod(exprType(node),
                                                &sourceBaseTypeMod);
 
        /*
         * Set up a CaseTestExpr representing one element of the source array.
         * This is an abuse of CaseTestExpr, but it's OK as long as there
         * can't be any CaseExpr or ArrayCoerceExpr within the completed
         * elemexpr.
         */
        ctest->typeId = get_element_type(sourceBaseTypeId);
        Assert(OidIsValid(ctest->typeId));
        ctest->typeMod = sourceBaseTypeMod;
        ctest->collation = InvalidOid;  /* Assume coercions don't care */
 
        /* And coerce it to the target element type */
        targetElementType = get_element_type(targetTypeId);
        Assert(OidIsValid(targetElementType));
 
        elemexpr = coerce_to_target_type(NULL,
                                         (Node *) ctest,
                                         ctest->typeId,
                                         targetElementType,
                                         targetTypMod,
                                         ccontext,
                                         cformat,
                                         location);
        if (elemexpr == NULL)   /* shouldn't happen */
            elog(ERROR, "failed to coerce array element type as expected");
 
        acoerce->arg = (Expr *) node;
        acoerce->elemexpr = (Expr *) elemexpr;
        acoerce->resulttype = targetTypeId;
 
        /*
         * Label the output as having a particular element typmod only if we
         * ended up with a per-element expression that is labeled that way.
         */
        acoerce->resulttypmod = exprTypmod(elemexpr);
        /* resultcollid will be set by parse_collate.c */
        acoerce->coerceformat = cformat;
        acoerce->location = location;
 
        return (Node *) acoerce;
    }
    else if (pathtype == COERCION_PATH_COERCEVIAIO)
    {
        /* We need to build a CoerceViaIO node */
        CoerceViaIO *iocoerce = makeNode(CoerceViaIO);
 
        Assert(!OidIsValid(funcId));
 
        iocoerce->arg = (Expr *) node;
        iocoerce->resulttype = targetTypeId;
        /* resultcollid will be set by parse_collate.c */
        iocoerce->coerceformat = cformat;
        iocoerce->location = location;
 
        return (Node *) iocoerce;
    }
    else
    {
        elog(ERROR, "unsupported pathtype %d in build_coercion_expression",
             (int) pathtype);
        return NULL;            /* keep compiler quiet */
    }
}

References CoerceViaIO::arg, Assert, BoolGetDatum(), coerce_to_target_type(), COERCION_EXPLICIT, COERCION_PATH_ARRAYCOERCE, COERCION_PATH_COERCEVIAIO, COERCION_PATH_FUNC, elog, ERROR, exprType(), exprTypmod(), fb(), Form_pg_proc, get_element_type(), getBaseTypeAndTypmod(), GETSTRUCT(), HeapTupleIsValid, Int32GetDatum(), InvalidOid, lappend(), list_make1, CoerceViaIO::location, makeConst(), makeFuncExpr(), makeNode, ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), CoerceViaIO::resulttype, and SearchSysCache1().

Referenced by coerce_type(), and coerce_type_typmod().

can_coerce_type()

bool can_coerce_type	(	int	nargs,
		const Oid *	input_typeids,
		const Oid *	target_typeids,
		CoercionContext	ccontext
	)

Definition at line 558 of file parse_coerce.c.

{
    bool        have_generics = false;
    int         i;
 
    /* run through argument list... */
    for (i = 0; i < nargs; i++)
    {
        Oid         inputTypeId = input_typeids[i];
        Oid         targetTypeId = target_typeids[i];
        CoercionPathType pathtype;
        Oid         funcId;
 
        /* no problem if same type */
        if (inputTypeId == targetTypeId)
            continue;
 
        /* accept if target is ANY */
        if (targetTypeId == ANYOID)
            continue;
 
        /* accept if target is polymorphic, for now */
        if (IsPolymorphicType(targetTypeId))
        {
            have_generics = true;   /* do more checking later */
            continue;
        }
 
        /*
         * If input is an untyped string constant, assume we can convert it to
         * anything.
         */
        if (inputTypeId == UNKNOWNOID)
            continue;
 
        /*
         * If pg_cast shows that we can coerce, accept.  This test now covers
         * both binary-compatible and coercion-function cases.
         */
        pathtype = find_coercion_pathway(targetTypeId, inputTypeId, ccontext,
                                         &funcId);
        if (pathtype != COERCION_PATH_NONE)
            continue;
 
        /*
         * If input is RECORD and target is a composite type, assume we can
         * coerce (may need tighter checking here)
         */
        if (inputTypeId == RECORDOID &&
            ISCOMPLEX(targetTypeId))
            continue;
 
        /*
         * If input is a composite type and target is RECORD, accept
         */
        if (targetTypeId == RECORDOID &&
            ISCOMPLEX(inputTypeId))
            continue;
 
#ifdef NOT_USED                 /* not implemented yet */
 
        /*
         * If input is record[] and target is a composite array type, assume
         * we can coerce (may need tighter checking here)
         */
        if (inputTypeId == RECORDARRAYOID &&
            is_complex_array(targetTypeId))
            continue;
#endif
 
        /*
         * If input is a composite array type and target is record[], accept
         */
        if (targetTypeId == RECORDARRAYOID &&
            is_complex_array(inputTypeId))
            continue;
 
        /*
         * If input is a class type that inherits from target, accept
         */
        if (typeInheritsFrom(inputTypeId, targetTypeId)
            || typeIsOfTypedTable(inputTypeId, targetTypeId))
            continue;
 
        /*
         * Else, cannot coerce at this argument position
         */
        return false;
    }
 
    /* If we found any generic argument types, cross-check them */
    if (have_generics)
    {
        if (!check_generic_type_consistency(input_typeids, target_typeids,
                                            nargs))
            return false;
    }
 
    return true;
}

References check_generic_type_consistency(), COERCION_PATH_NONE, fb(), find_coercion_pathway(), i, is_complex_array(), ISCOMPLEX, typeInheritsFrom(), and typeIsOfTypedTable().

Referenced by ATAddForeignKeyConstraint(), coerce_to_common_type(), coerce_to_target_type(), func_match_argtypes(), func_select_candidate(), jsonb_subscript_transform(), propgraph_edge_get_ref_keys(), select_common_type(), select_common_type_from_oids(), transformForPortionOfClause(), transformFrameOffset(), verify_common_type(), and verify_common_type_from_oids().

check_generic_type_consistency()

bool check_generic_type_consistency	(	const Oid *	actual_arg_types,
		const Oid *	declared_arg_types,
		int	nargs
	)

Definition at line 1737 of file parse_coerce.c.

{
    Oid         elem_typeid = InvalidOid;
    Oid         array_typeid = InvalidOid;
    Oid         range_typeid = InvalidOid;
    Oid         multirange_typeid = InvalidOid;
    Oid         anycompatible_range_typeid = InvalidOid;
    Oid         anycompatible_range_typelem = InvalidOid;
    Oid         anycompatible_multirange_typeid = InvalidOid;
    Oid         anycompatible_multirange_typelem = InvalidOid;
    Oid         range_typelem = InvalidOid;
    bool        have_anynonarray = false;
    bool        have_anyenum = false;
    bool        have_anycompatible_nonarray = false;
    int         n_anycompatible_args = 0;
    Oid         anycompatible_actual_types[FUNC_MAX_ARGS];
 
    /*
     * Loop through the arguments to see if we have any that are polymorphic.
     * If so, require the actual types to be consistent.
     */
    Assert(nargs <= FUNC_MAX_ARGS);
    for (int j = 0; j < nargs; j++)
    {
        Oid         decl_type = declared_arg_types[j];
        Oid         actual_type = actual_arg_types[j];
 
        if (decl_type == ANYELEMENTOID ||
            decl_type == ANYNONARRAYOID ||
            decl_type == ANYENUMOID)
        {
            if (decl_type == ANYNONARRAYOID)
                have_anynonarray = true;
            else if (decl_type == ANYENUMOID)
                have_anyenum = true;
            if (actual_type == UNKNOWNOID)
                continue;
            if (OidIsValid(elem_typeid) && actual_type != elem_typeid)
                return false;
            elem_typeid = actual_type;
        }
        else if (decl_type == ANYARRAYOID)
        {
            if (actual_type == UNKNOWNOID)
                continue;
            actual_type = getBaseType(actual_type); /* flatten domains */
            if (OidIsValid(array_typeid) && actual_type != array_typeid)
                return false;
            array_typeid = actual_type;
        }
        else if (decl_type == ANYRANGEOID)
        {
            if (actual_type == UNKNOWNOID)
                continue;
            actual_type = getBaseType(actual_type); /* flatten domains */
            if (OidIsValid(range_typeid) && actual_type != range_typeid)
                return false;
            range_typeid = actual_type;
        }
        else if (decl_type == ANYMULTIRANGEOID)
        {
            if (actual_type == UNKNOWNOID)
                continue;
            actual_type = getBaseType(actual_type); /* flatten domains */
            if (OidIsValid(multirange_typeid) && actual_type != multirange_typeid)
                return false;
            multirange_typeid = actual_type;
        }
        else if (decl_type == ANYCOMPATIBLEOID ||
                 decl_type == ANYCOMPATIBLENONARRAYOID)
        {
            if (decl_type == ANYCOMPATIBLENONARRAYOID)
                have_anycompatible_nonarray = true;
            if (actual_type == UNKNOWNOID)
                continue;
            /* collect the actual types of non-unknown COMPATIBLE args */
            anycompatible_actual_types[n_anycompatible_args++] = actual_type;
        }
        else if (decl_type == ANYCOMPATIBLEARRAYOID)
        {
            Oid         elem_type;
 
            if (actual_type == UNKNOWNOID)
                continue;
            actual_type = getBaseType(actual_type); /* flatten domains */
            elem_type = get_element_type(actual_type);
            if (!OidIsValid(elem_type))
                return false;   /* not an array */
            /* collect the element type for common-supertype choice */
            anycompatible_actual_types[n_anycompatible_args++] = elem_type;
        }
        else if (decl_type == ANYCOMPATIBLERANGEOID)
        {
            if (actual_type == UNKNOWNOID)
                continue;
            actual_type = getBaseType(actual_type); /* flatten domains */
            if (OidIsValid(anycompatible_range_typeid))
            {
                /* All ANYCOMPATIBLERANGE arguments must be the same type */
                if (anycompatible_range_typeid != actual_type)
                    return false;
            }
            else
            {
                anycompatible_range_typeid = actual_type;
                anycompatible_range_typelem = get_range_subtype(actual_type);
                if (!OidIsValid(anycompatible_range_typelem))
                    return false;   /* not a range type */
                /* collect the subtype for common-supertype choice */
                anycompatible_actual_types[n_anycompatible_args++] = anycompatible_range_typelem;
            }
        }
        else if (decl_type == ANYCOMPATIBLEMULTIRANGEOID)
        {
            if (actual_type == UNKNOWNOID)
                continue;
            actual_type = getBaseType(actual_type); /* flatten domains */
            if (OidIsValid(anycompatible_multirange_typeid))
            {
                /* All ANYCOMPATIBLEMULTIRANGE arguments must be the same type */
                if (anycompatible_multirange_typeid != actual_type)
                    return false;
            }
            else
            {
                anycompatible_multirange_typeid = actual_type;
                anycompatible_multirange_typelem = get_multirange_range(actual_type);
                if (!OidIsValid(anycompatible_multirange_typelem))
                    return false;   /* not a multirange type */
                /* we'll consider the subtype below */
            }
        }
    }
 
    /* Get the element type based on the array type, if we have one */
    if (OidIsValid(array_typeid))
    {
        if (array_typeid == ANYARRAYOID)
        {
            /*
             * Special case for matching ANYARRAY input to an ANYARRAY
             * argument: allow it for now.  enforce_generic_type_consistency()
             * might complain later, depending on the presence of other
             * polymorphic arguments or results, but it will deliver a less
             * surprising error message than "function does not exist".
             *
             * (If you think to change this, note that can_coerce_type will
             * consider such a situation as a match, so that we might not even
             * get here.)
             */
        }
        else
        {
            Oid         array_typelem;
 
            array_typelem = get_element_type(array_typeid);
            if (!OidIsValid(array_typelem))
                return false;   /* should be an array, but isn't */
 
            if (!OidIsValid(elem_typeid))
            {
                /*
                 * if we don't have an element type yet, use the one we just
                 * got
                 */
                elem_typeid = array_typelem;
            }
            else if (array_typelem != elem_typeid)
            {
                /* otherwise, they better match */
                return false;
            }
        }
    }
 
    /* Deduce range type from multirange type, or check that they agree */
    if (OidIsValid(multirange_typeid))
    {
        Oid         multirange_typelem;
 
        multirange_typelem = get_multirange_range(multirange_typeid);
        if (!OidIsValid(multirange_typelem))
            return false;       /* should be a multirange, but isn't */
 
        if (!OidIsValid(range_typeid))
        {
            /* If we don't have a range type yet, use the one we just got */
            range_typeid = multirange_typelem;
            range_typelem = get_range_subtype(multirange_typelem);
            if (!OidIsValid(range_typelem))
                return false;   /* should be a range, but isn't */
        }
        else if (multirange_typelem != range_typeid)
        {
            /* otherwise, they better match */
            return false;
        }
    }
 
    /* Get the element type based on the range type, if we have one */
    if (OidIsValid(range_typeid))
    {
        range_typelem = get_range_subtype(range_typeid);
        if (!OidIsValid(range_typelem))
            return false;       /* should be a range, but isn't */
 
        if (!OidIsValid(elem_typeid))
        {
            /*
             * If we don't have an element type yet, use the one we just got
             */
            elem_typeid = range_typelem;
        }
        else if (range_typelem != elem_typeid)
        {
            /* otherwise, they better match */
            return false;
        }
    }
 
    if (have_anynonarray)
    {
        /* require the element type to not be an array or domain over array */
        if (type_is_array_domain(elem_typeid))
            return false;
    }
 
    if (have_anyenum)
    {
        /* require the element type to be an enum */
        if (!type_is_enum(elem_typeid))
            return false;
    }
 
    /* Deduce range type from multirange type, or check that they agree */
    if (OidIsValid(anycompatible_multirange_typeid))
    {
        if (OidIsValid(anycompatible_range_typeid))
        {
            if (anycompatible_multirange_typelem !=
                anycompatible_range_typeid)
                return false;
        }
        else
        {
            anycompatible_range_typeid = anycompatible_multirange_typelem;
            anycompatible_range_typelem = get_range_subtype(anycompatible_range_typeid);
            if (!OidIsValid(anycompatible_range_typelem))
                return false;   /* not a range type */
            /* collect the subtype for common-supertype choice */
            anycompatible_actual_types[n_anycompatible_args++] =
                anycompatible_range_typelem;
        }
    }
 
    /* Check matching of ANYCOMPATIBLE-family arguments, if any */
    if (n_anycompatible_args > 0)
    {
        Oid         anycompatible_typeid;
 
        anycompatible_typeid =
            select_common_type_from_oids(n_anycompatible_args,
                                         anycompatible_actual_types,
                                         true);
 
        if (!OidIsValid(anycompatible_typeid))
            return false;       /* there's definitely no common supertype */
 
        /* We have to verify that the selected type actually works */
        if (!verify_common_type_from_oids(anycompatible_typeid,
                                          n_anycompatible_args,
                                          anycompatible_actual_types))
            return false;
 
        if (have_anycompatible_nonarray)
        {
            /*
             * require the anycompatible type to not be an array or domain
             * over array
             */
            if (type_is_array_domain(anycompatible_typeid))
                return false;
        }
 
        /*
         * The anycompatible type must exactly match the range element type,
         * if we were able to identify one. This checks compatibility for
         * anycompatiblemultirange too since that also sets
         * anycompatible_range_typelem above.
         */
        if (OidIsValid(anycompatible_range_typelem) &&
            anycompatible_range_typelem != anycompatible_typeid)
            return false;
    }
 
    /* Looks valid */
    return true;
}

References Assert, fb(), FUNC_MAX_ARGS, get_element_type(), get_multirange_range(), get_range_subtype(), getBaseType(), InvalidOid, j, OidIsValid, select_common_type_from_oids(), type_is_array_domain, type_is_enum(), and verify_common_type_from_oids().

Referenced by can_coerce_type().

check_valid_internal_signature()

char * check_valid_internal_signature	(	Oid	ret_type,
		const Oid *	declared_arg_types,
		int	nargs
	)

Definition at line 2952 of file parse_coerce.c.

{
    if (ret_type == INTERNALOID)
    {
        for (int i = 0; i < nargs; i++)
        {
            if (declared_arg_types[i] == ret_type)
                return NULL;    /* OK */
        }
        return pstrdup(_("A result of type internal requires at least one input of type internal."));
    }
    else
        return NULL;            /* OK, ret_type is not INTERNAL */
}

References _, fb(), i, and pstrdup().

Referenced by AggregateCreate(), and ProcedureCreate().

check_valid_polymorphic_signature()

char * check_valid_polymorphic_signature	(	Oid	ret_type,
		const Oid *	declared_arg_types,
		int	nargs
	)

Definition at line 2875 of file parse_coerce.c.

{
    if (ret_type == ANYRANGEOID || ret_type == ANYMULTIRANGEOID)
    {
        /*
         * ANYRANGE and ANYMULTIRANGE require an ANYRANGE or ANYMULTIRANGE
         * input, else we can't tell which of several range types with the
         * same element type to use.
         */
        for (int i = 0; i < nargs; i++)
        {
            if (declared_arg_types[i] == ANYRANGEOID ||
                declared_arg_types[i] == ANYMULTIRANGEOID)
                return NULL;    /* OK */
        }
        return psprintf(_("A result of type %s requires at least one input of type anyrange or anymultirange."),
                        format_type_be(ret_type));
    }
    else if (ret_type == ANYCOMPATIBLERANGEOID || ret_type == ANYCOMPATIBLEMULTIRANGEOID)
    {
        /*
         * ANYCOMPATIBLERANGE and ANYCOMPATIBLEMULTIRANGE require an
         * ANYCOMPATIBLERANGE or ANYCOMPATIBLEMULTIRANGE input, else we can't
         * tell which of several range types with the same element type to
         * use.
         */
        for (int i = 0; i < nargs; i++)
        {
            if (declared_arg_types[i] == ANYCOMPATIBLERANGEOID ||
                declared_arg_types[i] == ANYCOMPATIBLEMULTIRANGEOID)
                return NULL;    /* OK */
        }
        return psprintf(_("A result of type %s requires at least one input of type anycompatiblerange or anycompatiblemultirange."),
                        format_type_be(ret_type));
    }
    else if (IsPolymorphicTypeFamily1(ret_type))
    {
        /* Otherwise, any family-1 type can be deduced from any other */
        for (int i = 0; i < nargs; i++)
        {
            if (IsPolymorphicTypeFamily1(declared_arg_types[i]))
                return NULL;    /* OK */
        }
        /* Keep this list in sync with IsPolymorphicTypeFamily1! */
        return psprintf(_("A result of type %s requires at least one input of type anyelement, anyarray, anynonarray, anyenum, anyrange, or anymultirange."),
                        format_type_be(ret_type));
    }
    else if (IsPolymorphicTypeFamily2(ret_type))
    {
        /* Otherwise, any family-2 type can be deduced from any other */
        for (int i = 0; i < nargs; i++)
        {
            if (IsPolymorphicTypeFamily2(declared_arg_types[i]))
                return NULL;    /* OK */
        }
        /* Keep this list in sync with IsPolymorphicTypeFamily2! */
        return psprintf(_("A result of type %s requires at least one input of type anycompatible, anycompatiblearray, anycompatiblenonarray, anycompatiblerange, or anycompatiblemultirange."),
                        format_type_be(ret_type));
    }
    else
        return NULL;            /* OK, ret_type is not polymorphic */
}

References _, fb(), format_type_be(), i, and psprintf().

Referenced by AggregateCreate(), and ProcedureCreate().

coerce_null_to_domain()

Node * coerce_null_to_domain	(	Oid	typid,
		int32	typmod,
		Oid	collation,
		int	typlen,
		bool	typbyval
	)

Definition at line 1271 of file parse_coerce.c.

{
    Node       *result;
    Oid         baseTypeId;
    int32       baseTypeMod = typmod;
 
    /*
     * The constant must appear to have the domain's base type/typmod, else
     * coerce_to_domain() will apply a length coercion which is useless.
     */
    baseTypeId = getBaseTypeAndTypmod(typid, &baseTypeMod);
    result = (Node *) makeConst(baseTypeId,
                                baseTypeMod,
                                collation,
                                typlen,
                                (Datum) 0,
                                true,   /* isnull */
                                typbyval);
    if (typid != baseTypeId)
        result = coerce_to_domain(result,
                                  baseTypeId, baseTypeMod,
                                  typid,
                                  COERCION_IMPLICIT,
                                  COERCE_IMPLICIT_CAST,
                                  -1,
                                  false);
    return result;
}

References COERCE_IMPLICIT_CAST, coerce_to_domain(), COERCION_IMPLICIT, fb(), getBaseTypeAndTypmod(), makeConst(), and result.

Referenced by expand_insert_targetlist(), ReplaceVarFromTargetList(), rewriteTargetListIU(), and rewriteValuesRTE().

coerce_record_to_complex()

static Node * coerce_record_to_complex ( ParseState *  pstate, Node *  node, Oid  targetTypeId, CoercionContext  ccontext, CoercionForm  cformat, int  location  )

static

Definition at line 1011 of file parse_coerce.c.

{
    RowExpr    *rowexpr;
    Oid         baseTypeId;
    int32       baseTypeMod = -1;
    TupleDesc   tupdesc;
    List       *args = NIL;
    List       *newargs;
    int         i;
    int         ucolno;
    ListCell   *arg;
 
    if (node && IsA(node, RowExpr))
    {
        /*
         * Since the RowExpr must be of type RECORD, we needn't worry about it
         * containing any dropped columns.
         */
        args = ((RowExpr *) node)->args;
    }
    else if (node && IsA(node, Var) &&
             ((Var *) node)->varattno == InvalidAttrNumber)
    {
        Var        *var = (Var *) node;
        ParseNamespaceItem *nsitem;
 
        nsitem = GetNSItemByVar(pstate, var);
        args = expandNSItemVars(pstate, nsitem, var->varlevelsup,
                                var->location, NULL);
    }
    else
        ereport(ERROR,
                (errcode(ERRCODE_CANNOT_COERCE),
                 errmsg("cannot cast type %s to %s",
                        format_type_be(RECORDOID),
                        format_type_be(targetTypeId)),
                 parser_coercion_errposition(pstate, location, node)));
 
    /*
     * Look up the composite type, accounting for possibility that what we are
     * given is a domain over composite.
     */
    baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod);
    tupdesc = lookup_rowtype_tupdesc(baseTypeId, baseTypeMod);
 
    /* Process the fields */
    newargs = NIL;
    ucolno = 1;
    arg = list_head(args);
    for (i = 0; i < tupdesc->natts; i++)
    {
        Node       *expr;
        Node       *cexpr;
        Oid         exprtype;
        Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
 
        /* Fill in NULLs for dropped columns in rowtype */
        if (attr->attisdropped)
        {
            /*
             * can't use atttypid here, but it doesn't really matter what type
             * the Const claims to be.
             */
            newargs = lappend(newargs,
                              makeNullConst(INT4OID, -1, InvalidOid));
            continue;
        }
 
        if (arg == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_CANNOT_COERCE),
                     errmsg("cannot cast type %s to %s",
                            format_type_be(RECORDOID),
                            format_type_be(targetTypeId)),
                     errdetail("Input has too few columns."),
                     parser_coercion_errposition(pstate, location, node)));
        expr = (Node *) lfirst(arg);
        exprtype = exprType(expr);
 
        cexpr = coerce_to_target_type(pstate,
                                      expr, exprtype,
                                      attr->atttypid,
                                      attr->atttypmod,
                                      ccontext,
                                      COERCE_IMPLICIT_CAST,
                                      -1);
        if (cexpr == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_CANNOT_COERCE),
                     errmsg("cannot cast type %s to %s",
                            format_type_be(RECORDOID),
                            format_type_be(targetTypeId)),
                     errdetail("Cannot cast type %s to %s in column %d.",
                               format_type_be(exprtype),
                               format_type_be(attr->atttypid),
                               ucolno),
                     parser_coercion_errposition(pstate, location, expr)));
        newargs = lappend(newargs, cexpr);
        ucolno++;
        arg = lnext(args, arg);
    }
    if (arg != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_CANNOT_COERCE),
                 errmsg("cannot cast type %s to %s",
                        format_type_be(RECORDOID),
                        format_type_be(targetTypeId)),
                 errdetail("Input has too many columns."),
                 parser_coercion_errposition(pstate, location, node)));
 
    ReleaseTupleDesc(tupdesc);
 
    rowexpr = makeNode(RowExpr);
    rowexpr->args = newargs;
    rowexpr->row_typeid = baseTypeId;
    rowexpr->row_format = cformat;
    rowexpr->colnames = NIL;    /* not needed for named target type */
    rowexpr->location = location;
 
    /* If target is a domain, apply constraints */
    if (baseTypeId != targetTypeId)
    {
        rowexpr->row_format = COERCE_IMPLICIT_CAST;
        return coerce_to_domain((Node *) rowexpr,
                                baseTypeId, baseTypeMod,
                                targetTypeId,
                                ccontext, cformat, location,
                                false);
    }
 
    return (Node *) rowexpr;
}

References arg, RowExpr::args, COERCE_IMPLICIT_CAST, coerce_to_domain(), coerce_to_target_type(), ereport, errcode(), errdetail(), errmsg, ERROR, expandNSItemVars(), exprType(), fb(), format_type_be(), getBaseTypeAndTypmod(), GetNSItemByVar(), i, InvalidAttrNumber, InvalidOid, IsA, lappend(), lfirst, list_head(), lnext(), Var::location, RowExpr::location, lookup_rowtype_tupdesc(), makeNode, makeNullConst(), TupleDescData::natts, NIL, parser_coercion_errposition(), ReleaseTupleDesc, TupleDescAttr(), and Var::varlevelsup.

Referenced by coerce_type().

coerce_to_boolean()

Node * coerce_to_boolean	(	ParseState *	pstate,
		Node *	node,
		const char *	constructName
	)

Definition at line 1159 of file parse_coerce.c.

{
    Oid         inputTypeId = exprType(node);
 
    if (inputTypeId != BOOLOID)
    {
        Node       *newnode;
 
        newnode = coerce_to_target_type(pstate, node, inputTypeId,
                                        BOOLOID, -1,
                                        COERCION_ASSIGNMENT,
                                        COERCE_IMPLICIT_CAST,
                                        -1);
        if (newnode == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
            /* translator: first %s is name of a SQL construct, eg WHERE */
                     errmsg("argument of %s must be type %s, not type %s",
                            constructName, "boolean",
                            format_type_be(inputTypeId)),
                     parser_errposition(pstate, exprLocation(node))));
        node = newnode;
    }
 
    if (expression_returns_set(node))
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
        /* translator: %s is name of a SQL construct, eg WHERE */
                 errmsg("argument of %s must not return a set",
                        constructName),
                 parser_errposition(pstate, exprLocation(node))));
 
    return node;
}

References COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, ereport, errcode(), errmsg, ERROR, expression_returns_set(), exprLocation(), exprType(), fb(), format_type_be(), and parser_errposition().

Referenced by cookConstraint(), DoCopy(), domainAddCheckConstraint(), transformAExprIn(), transformBooleanTest(), transformBoolExpr(), transformCaseExpr(), transformJoinUsingClause(), transformWhereClause(), and transformXmlExpr().

coerce_to_common_type()

Node * coerce_to_common_type	(	ParseState *	pstate,
		Node *	node,
		Oid	targetTypeId,
		const char *	context
	)

Definition at line 1572 of file parse_coerce.c.

{
    Oid         inputTypeId = exprType(node);
 
    if (inputTypeId == targetTypeId)
        return node;            /* no work */
    if (can_coerce_type(1, &inputTypeId, &targetTypeId, COERCION_IMPLICIT))
        node = coerce_type(pstate, node, inputTypeId, targetTypeId, -1,
                           COERCION_IMPLICIT, COERCE_IMPLICIT_CAST, -1);
    else
        ereport(ERROR,
                (errcode(ERRCODE_CANNOT_COERCE),
        /* translator: first %s is name of a SQL construct, eg CASE */
                 errmsg("%s could not convert type %s to %s",
                        context,
                        format_type_be(inputTypeId),
                        format_type_be(targetTypeId)),
                 parser_errposition(pstate, exprLocation(node))));
    return node;
}

References can_coerce_type(), COERCE_IMPLICIT_CAST, coerce_type(), COERCION_IMPLICIT, ereport, errcode(), errmsg, ERROR, exprLocation(), exprType(), fb(), format_type_be(), and parser_errposition().

Referenced by analyzeCTE(), constructSetOpTargetlist(), generate_setop_tlist(), transformAExprIn(), transformArrayExpr(), transformCaseExpr(), transformCoalesceExpr(), transformMinMaxExpr(), and transformValuesClause().

coerce_to_domain()

Node * coerce_to_domain	(	Node *	arg,
		Oid	baseTypeId,
		int32	baseTypeMod,
		Oid	typeId,
		CoercionContext	ccontext,
		CoercionForm	cformat,
		int	location,
		bool	hideInputCoercion
	)

Definition at line 676 of file parse_coerce.c.

{
    CoerceToDomain *result;
 
    /* We now require the caller to supply correct baseTypeId/baseTypeMod */
    Assert(OidIsValid(baseTypeId));
 
    /* If it isn't a domain, return the node as it was passed in */
    if (baseTypeId == typeId)
        return arg;
 
    /* Suppress display of nested coercion steps */
    if (hideInputCoercion)
        hide_coercion_node(arg);
 
    /*
     * If the domain applies a typmod to its base type, build the appropriate
     * coercion step.  Mark it implicit for display purposes, because we don't
     * want it shown separately by ruleutils.c; but the isExplicit flag passed
     * to the conversion function depends on the manner in which the domain
     * coercion is invoked, so that the semantics of implicit and explicit
     * coercion differ.  (Is that really the behavior we want?)
     *
     * NOTE: because we apply this as part of the fixed expression structure,
     * ALTER DOMAIN cannot alter the typtypmod.  But it's unclear that that
     * would be safe to do anyway, without lots of knowledge about what the
     * base type thinks the typmod means.
     */
    arg = coerce_type_typmod(arg, baseTypeId, baseTypeMod,
                             ccontext, COERCE_IMPLICIT_CAST, location,
                             false);
 
    /*
     * Now build the domain coercion node.  This represents run-time checking
     * of any constraints currently attached to the domain.  This also ensures
     * that the expression is properly labeled as to result type.
     */
    result = makeNode(CoerceToDomain);
    result->arg = (Expr *) arg;
    result->resulttype = typeId;
    result->resulttypmod = -1;  /* currently, always -1 for domains */
    /* resultcollid will be set by parse_collate.c */
    result->coercionformat = cformat;
    result->location = location;
 
    return (Node *) result;
}

References arg, Assert, COERCE_IMPLICIT_CAST, coerce_type_typmod(), fb(), hide_coercion_node(), makeNode, OidIsValid, and result.

Referenced by coerce_null_to_domain(), coerce_record_to_complex(), coerce_type(), and transformAssignmentIndirection().

coerce_to_specific_type()

Node * coerce_to_specific_type	(	ParseState *	pstate,
		Node *	node,
		Oid	targetTypeId,
		const char *	constructName
	)

Definition at line 1255 of file parse_coerce.c.

{
    return coerce_to_specific_type_typmod(pstate, node,
                                          targetTypeId, -1,
                                          constructName);
}

References coerce_to_specific_type_typmod(), and fb().

Referenced by coerceJsonFuncExpr(), interpret_function_parameter_list(), transformFrameOffset(), transformJsonScalarExpr(), transformJsonValueExpr(), transformLimitClause(), transformRangeTableFunc(), transformRangeTableSample(), transformXmlExpr(), and transformXmlSerialize().

coerce_to_specific_type_typmod()

Node * coerce_to_specific_type_typmod	(	ParseState *	pstate,
		Node *	node,
		Oid	targetTypeId,
		int32	targetTypmod,
		const char *	constructName
	)

Definition at line 1206 of file parse_coerce.c.

{
    Oid         inputTypeId = exprType(node);
 
    if (inputTypeId != targetTypeId)
    {
        Node       *newnode;
 
        newnode = coerce_to_target_type(pstate, node, inputTypeId,
                                        targetTypeId, targetTypmod,
                                        COERCION_ASSIGNMENT,
                                        COERCE_IMPLICIT_CAST,
                                        -1);
        if (newnode == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
            /* translator: first %s is name of a SQL construct, eg LIMIT */
                     errmsg("argument of %s must be type %s, not type %s",
                            constructName,
                            format_type_be(targetTypeId),
                            format_type_be(inputTypeId)),
                     parser_errposition(pstate, exprLocation(node))));
        node = newnode;
    }
 
    if (expression_returns_set(node))
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
        /* translator: %s is name of a SQL construct, eg LIMIT */
                 errmsg("argument of %s must not return a set",
                        constructName),
                 parser_errposition(pstate, exprLocation(node))));
 
    return node;
}

References COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, ereport, errcode(), errmsg, ERROR, expression_returns_set(), exprLocation(), exprType(), fb(), format_type_be(), and parser_errposition().

Referenced by coerce_to_specific_type(), and transformRangeTableFunc().

coerce_to_target_type()

Node * coerce_to_target_type	(	ParseState *	pstate,
		Node *	expr,
		Oid	exprtype,
		Oid	targettype,
		int32	targettypmod,
		CoercionContext	ccontext,
		CoercionForm	cformat,
		int	location
	)

Definition at line 79 of file parse_coerce.c.

{
    Node       *result;
    Node       *origexpr;
 
    if (!can_coerce_type(1, &exprtype, &targettype, ccontext))
        return NULL;
 
    /*
     * If the input has a CollateExpr at the top, strip it off, perform the
     * coercion, and put a new one back on.  This is annoying since it
     * duplicates logic in coerce_type, but if we don't do this then it's too
     * hard to tell whether coerce_type actually changed anything, and we
     * *must* know that to avoid possibly calling hide_coercion_node on
     * something that wasn't generated by coerce_type.  Note that if there are
     * multiple stacked CollateExprs, we just discard all but the topmost.
     * Also, if the target type isn't collatable, we discard the CollateExpr.
     */
    origexpr = expr;
    while (expr && IsA(expr, CollateExpr))
        expr = (Node *) ((CollateExpr *) expr)->arg;
 
    result = coerce_type(pstate, expr, exprtype,
                         targettype, targettypmod,
                         ccontext, cformat, location);
 
    /*
     * If the target is a fixed-length type, it may need a length coercion as
     * well as a type coercion.  If we find ourselves adding both, force the
     * inner coercion node to implicit display form.
     */
    result = coerce_type_typmod(result,
                                targettype, targettypmod,
                                ccontext, cformat, location,
                                (result != expr && !IsA(result, Const)));
 
    if (expr != origexpr && type_is_collatable(targettype))
    {
        /* Reinstall top CollateExpr */
        CollateExpr *coll = (CollateExpr *) origexpr;
        CollateExpr *newcoll = makeNode(CollateExpr);
 
        newcoll->arg = (Expr *) result;
        newcoll->collOid = coll->collOid;
        newcoll->location = coll->location;
        result = (Node *) newcoll;
    }
 
    return result;
}

References arg, can_coerce_type(), coerce_type(), coerce_type_typmod(), CollateExpr::collOid, fb(), IsA, CollateExpr::location, makeNode, result, and type_is_collatable().

Referenced by array_subscript_transform(), ATExecAddColumn(), ATExecAlterColumnType(), ATPrepAlterColumnType(), build_coercion_expression(), build_column_default(), coerce_fn_result_column(), coerce_record_to_complex(), coerce_to_boolean(), coerce_to_specific_type_typmod(), coerceJsonFuncExpr(), cookDefault(), EvaluateParams(), get_cast_hashentry(), hstore_subscript_transform(), transformArrayExpr(), transformAssignedExpr(), transformAssignmentIndirection(), transformAssignmentSubscripts(), transformJsonBehavior(), transformJsonFuncExpr(), transformJsonParseArg(), transformJsonValueExpr(), transformPartitionBoundValue(), transformPLAssignStmtTarget(), transformTypeCast(), and transformXmlSerialize().

coerce_type()

Node * coerce_type	(	ParseState *	pstate,
		Node *	node,
		Oid	inputTypeId,
		Oid	targetTypeId,
		int32	targetTypeMod,
		CoercionContext	ccontext,
		CoercionForm	cformat,
		int	location
	)

Definition at line 158 of file parse_coerce.c.

{
    Node       *result;
    CoercionPathType pathtype;
    Oid         funcId;
 
    if (targetTypeId == inputTypeId ||
        node == NULL)
    {
        /* no conversion needed */
        return node;
    }
    if (targetTypeId == ANYOID ||
        targetTypeId == ANYELEMENTOID ||
        targetTypeId == ANYNONARRAYOID ||
        targetTypeId == ANYCOMPATIBLEOID ||
        targetTypeId == ANYCOMPATIBLENONARRAYOID)
    {
        /*
         * Assume can_coerce_type verified that implicit coercion is okay.
         *
         * Note: by returning the unmodified node here, we are saying that
         * it's OK to treat an UNKNOWN constant as a valid input for a
         * function accepting one of these pseudotypes.  This should be all
         * right, since an UNKNOWN value is still a perfectly valid Datum.
         *
         * NB: we do NOT want a RelabelType here: the exposed type of the
         * function argument must be its actual type, not the polymorphic
         * pseudotype.
         */
        return node;
    }
    if (targetTypeId == ANYARRAYOID ||
        targetTypeId == ANYENUMOID ||
        targetTypeId == ANYRANGEOID ||
        targetTypeId == ANYMULTIRANGEOID ||
        targetTypeId == ANYCOMPATIBLEARRAYOID ||
        targetTypeId == ANYCOMPATIBLERANGEOID ||
        targetTypeId == ANYCOMPATIBLEMULTIRANGEOID)
    {
        /*
         * Assume can_coerce_type verified that implicit coercion is okay.
         *
         * These cases are unlike the ones above because the exposed type of
         * the argument must be an actual array, enum, range, or multirange
         * type.  In particular the argument must *not* be an UNKNOWN
         * constant.  If it is, we just fall through; below, we'll call the
         * pseudotype's input function, which will produce an error.  Also, if
         * what we have is a domain over array, enum, range, or multirange, we
         * have to relabel it to its base type.
         *
         * Note: currently, we can't actually see a domain-over-enum here,
         * since the other functions in this file will not match such a
         * parameter to ANYENUM.  But that should get changed eventually.
         */
        if (inputTypeId != UNKNOWNOID)
        {
            Oid         baseTypeId = getBaseType(inputTypeId);
 
            if (baseTypeId != inputTypeId)
            {
                RelabelType *r = makeRelabelType((Expr *) node,
                                                 baseTypeId, -1,
                                                 InvalidOid,
                                                 cformat);
 
                r->location = location;
                return (Node *) r;
            }
            /* Not a domain type, so return it as-is */
            return node;
        }
    }
    if (inputTypeId == UNKNOWNOID && IsA(node, Const))
    {
        /*
         * Input is a string constant with previously undetermined type. Apply
         * the target type's typinput function to it to produce a constant of
         * the target type.
         *
         * NOTE: this case cannot be folded together with the other
         * constant-input case, since the typinput function does not
         * necessarily behave the same as a type conversion function. For
         * example, int4's typinput function will reject "1.2", whereas
         * float-to-int type conversion will round to integer.
         *
         * XXX if the typinput function is not immutable, we really ought to
         * postpone evaluation of the function call until runtime. But there
         * is no way to represent a typinput function call as an expression
         * tree, because C-string values are not Datums. (XXX This *is*
         * possible as of 7.3, do we want to do it?)
         */
        Const      *con = (Const *) node;
        Const      *newcon = makeNode(Const);
        Oid         baseTypeId;
        int32       baseTypeMod;
        int32       inputTypeMod;
        Type        baseType;
        ParseCallbackState pcbstate;
 
        /*
         * If the target type is a domain, we want to call its base type's
         * input routine, not domain_in().  This is to avoid premature failure
         * when the domain applies a typmod: existing input routines follow
         * implicit-coercion semantics for length checks, which is not always
         * what we want here.  The needed check will be applied properly
         * inside coerce_to_domain().
         */
        baseTypeMod = targetTypeMod;
        baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod);
 
        /*
         * For most types we pass typmod -1 to the input routine, because
         * existing input routines follow implicit-coercion semantics for
         * length checks, which is not always what we want here.  Any length
         * constraint will be applied later by our caller.  An exception
         * however is the INTERVAL type, for which we *must* pass the typmod
         * or it won't be able to obey the bizarre SQL-spec input rules. (Ugly
         * as sin, but so is this part of the spec...)
         */
        if (baseTypeId == INTERVALOID)
            inputTypeMod = baseTypeMod;
        else
            inputTypeMod = -1;
 
        baseType = typeidType(baseTypeId);
 
        newcon->consttype = baseTypeId;
        newcon->consttypmod = inputTypeMod;
        newcon->constcollid = typeTypeCollation(baseType);
        newcon->constlen = typeLen(baseType);
        newcon->constbyval = typeByVal(baseType);
        newcon->constisnull = con->constisnull;
 
        /*
         * We use the original literal's location regardless of the position
         * of the coercion.  This is a change from pre-9.2 behavior, meant to
         * simplify life for pg_stat_statements.
         */
        newcon->location = con->location;
 
        /*
         * Set up to point at the constant's text if the input routine throws
         * an error.
         */
        setup_parser_errposition_callback(&pcbstate, pstate, con->location);
 
        /*
         * We assume here that UNKNOWN's internal representation is the same
         * as CSTRING.
         */
        if (!con->constisnull)
            newcon->constvalue = stringTypeDatum(baseType,
                                                 DatumGetCString(con->constvalue),
                                                 inputTypeMod);
        else
            newcon->constvalue = stringTypeDatum(baseType,
                                                 NULL,
                                                 inputTypeMod);
 
        /*
         * If it's a varlena value, force it to be in non-expanded
         * (non-toasted) format; this avoids any possible dependency on
         * external values and improves consistency of representation.
         */
        if (!con->constisnull && newcon->constlen == -1)
            newcon->constvalue =
                PointerGetDatum(PG_DETOAST_DATUM(newcon->constvalue));
 
#ifdef RANDOMIZE_ALLOCATED_MEMORY
 
        /*
         * For pass-by-reference data types, repeat the conversion to see if
         * the input function leaves any uninitialized bytes in the result. We
         * can only detect that reliably if RANDOMIZE_ALLOCATED_MEMORY is
         * enabled, so we don't bother testing otherwise.  The reason we don't
         * want any instability in the input function is that comparison of
         * Const nodes relies on bytewise comparison of the datums, so if the
         * input function leaves garbage then subexpressions that should be
         * identical may not get recognized as such.  See pgsql-hackers
         * discussion of 2008-04-04.
         */
        if (!con->constisnull && !newcon->constbyval)
        {
            Datum       val2;
 
            val2 = stringTypeDatum(baseType,
                                   DatumGetCString(con->constvalue),
                                   inputTypeMod);
            if (newcon->constlen == -1)
                val2 = PointerGetDatum(PG_DETOAST_DATUM(val2));
            if (!datumIsEqual(newcon->constvalue, val2, false, newcon->constlen))
                elog(WARNING, "type %s has unstable input conversion for \"%s\"",
                     typeTypeName(baseType), DatumGetCString(con->constvalue));
        }
#endif
 
        cancel_parser_errposition_callback(&pcbstate);
 
        result = (Node *) newcon;
 
        /* If target is a domain, apply constraints. */
        if (baseTypeId != targetTypeId)
            result = coerce_to_domain(result,
                                      baseTypeId, baseTypeMod,
                                      targetTypeId,
                                      ccontext, cformat, location,
                                      false);
 
        ReleaseSysCache(baseType);
 
        return result;
    }
    if (IsA(node, Param) &&
        pstate != NULL && pstate->p_coerce_param_hook != NULL)
    {
        /*
         * Allow the CoerceParamHook to decide what happens.  It can return a
         * transformed node (very possibly the same Param node), or return
         * NULL to indicate we should proceed with normal coercion.
         */
        result = pstate->p_coerce_param_hook(pstate,
                                             (Param *) node,
                                             targetTypeId,
                                             targetTypeMod,
                                             location);
        if (result)
            return result;
    }
    if (IsA(node, CollateExpr))
    {
        /*
         * If we have a COLLATE clause, we have to push the coercion
         * underneath the COLLATE; or discard the COLLATE if the target type
         * isn't collatable.  This is really ugly, but there is little choice
         * because the above hacks on Consts and Params wouldn't happen
         * otherwise.  This kluge has consequences in coerce_to_target_type.
         */
        CollateExpr *coll = (CollateExpr *) node;
 
        result = coerce_type(pstate, (Node *) coll->arg,
                             inputTypeId, targetTypeId, targetTypeMod,
                             ccontext, cformat, location);
        if (type_is_collatable(targetTypeId))
        {
            CollateExpr *newcoll = makeNode(CollateExpr);
 
            newcoll->arg = (Expr *) result;
            newcoll->collOid = coll->collOid;
            newcoll->location = coll->location;
            result = (Node *) newcoll;
        }
        return result;
    }
    pathtype = find_coercion_pathway(targetTypeId, inputTypeId, ccontext,
                                     &funcId);
    if (pathtype != COERCION_PATH_NONE)
    {
        Oid         baseTypeId;
        int32       baseTypeMod;
 
        baseTypeMod = targetTypeMod;
        baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod);
 
        if (pathtype != COERCION_PATH_RELABELTYPE)
        {
            /*
             * Generate an expression tree representing run-time application
             * of the conversion function.  If we are dealing with a domain
             * target type, the conversion function will yield the base type,
             * and we need to extract the correct typmod to use from the
             * domain's typtypmod.
             */
            result = build_coercion_expression(node, pathtype, funcId,
                                               baseTypeId, baseTypeMod,
                                               ccontext, cformat, location);
 
            /*
             * If domain, coerce to the domain type and relabel with domain
             * type ID, hiding the previous coercion node.
             */
            if (targetTypeId != baseTypeId)
                result = coerce_to_domain(result, baseTypeId, baseTypeMod,
                                          targetTypeId,
                                          ccontext, cformat, location,
                                          true);
        }
        else
        {
            /*
             * We don't need to do a physical conversion, but we do need to
             * attach a RelabelType node so that the expression will be seen
             * to have the intended type when inspected by higher-level code.
             *
             * Also, domains may have value restrictions beyond the base type
             * that must be accounted for.  If the destination is a domain
             * then we won't need a RelabelType node.
             */
            result = coerce_to_domain(node, baseTypeId, baseTypeMod,
                                      targetTypeId,
                                      ccontext, cformat, location,
                                      false);
            if (result == node)
            {
                /*
                 * XXX could we label result with exprTypmod(node) instead of
                 * default -1 typmod, to save a possible length-coercion
                 * later? Would work if both types have same interpretation of
                 * typmod, which is likely but not certain.
                 */
                RelabelType *r = makeRelabelType((Expr *) result,
                                                 targetTypeId, -1,
                                                 InvalidOid,
                                                 cformat);
 
                r->location = location;
                result = (Node *) r;
            }
        }
        return result;
    }
    if (inputTypeId == RECORDOID &&
        ISCOMPLEX(targetTypeId))
    {
        /* Coerce a RECORD to a specific complex type */
        return coerce_record_to_complex(pstate, node, targetTypeId,
                                        ccontext, cformat, location);
    }
    if (targetTypeId == RECORDOID &&
        ISCOMPLEX(inputTypeId))
    {
        /* Coerce a specific complex type to RECORD */
        /* NB: we do NOT want a RelabelType here */
        return node;
    }
#ifdef NOT_USED
    if (inputTypeId == RECORDARRAYOID &&
        is_complex_array(targetTypeId))
    {
        /* Coerce record[] to a specific complex array type */
        /* not implemented yet ... */
    }
#endif
    if (targetTypeId == RECORDARRAYOID &&
        is_complex_array(inputTypeId))
    {
        /* Coerce a specific complex array type to record[] */
        /* NB: we do NOT want a RelabelType here */
        return node;
    }
    if (typeInheritsFrom(inputTypeId, targetTypeId)
        || typeIsOfTypedTable(inputTypeId, targetTypeId))
    {
        /*
         * Input class type is a subclass of target, so generate an
         * appropriate runtime conversion (removing unneeded columns and
         * possibly rearranging the ones that are wanted).
         *
         * We will also get here when the input is a domain over a subclass of
         * the target type.  To keep life simple for the executor, we define
         * ConvertRowtypeExpr as only working between regular composite types;
         * therefore, in such cases insert a RelabelType to smash the input
         * expression down to its base type.
         */
        Oid         baseTypeId = getBaseType(inputTypeId);
        ConvertRowtypeExpr *r = makeNode(ConvertRowtypeExpr);
 
        if (baseTypeId != inputTypeId)
        {
            RelabelType *rt = makeRelabelType((Expr *) node,
                                              baseTypeId, -1,
                                              InvalidOid,
                                              COERCE_IMPLICIT_CAST);
 
            rt->location = location;
            node = (Node *) rt;
        }
        r->arg = (Expr *) node;
        r->resulttype = targetTypeId;
        r->convertformat = cformat;
        r->location = location;
        return (Node *) r;
    }
    /* If we get here, caller blew it */
    elog(ERROR, "failed to find conversion function from %s to %s",
         format_type_be(inputTypeId), format_type_be(targetTypeId));
    return NULL;                /* keep compiler quiet */
}

References ConvertRowtypeExpr::arg, CollateExpr::arg, build_coercion_expression(), cancel_parser_errposition_callback(), COERCE_IMPLICIT_CAST, coerce_record_to_complex(), coerce_to_domain(), coerce_type(), COERCION_PATH_NONE, COERCION_PATH_RELABELTYPE, CollateExpr::collOid, DatumGetCString(), datumIsEqual(), elog, ERROR, fb(), find_coercion_pathway(), format_type_be(), getBaseType(), getBaseTypeAndTypmod(), InvalidOid, is_complex_array(), IsA, ISCOMPLEX, RelabelType::location, ConvertRowtypeExpr::location, CollateExpr::location, makeNode, makeRelabelType(), ParseState::p_coerce_param_hook, PG_DETOAST_DATUM, PointerGetDatum, ReleaseSysCache(), result, ConvertRowtypeExpr::resulttype, setup_parser_errposition_callback(), stringTypeDatum(), type_is_collatable(), typeByVal(), typeidType(), typeInheritsFrom(), typeIsOfTypedTable(), typeLen(), typeTypeCollation(), typeTypeName(), and WARNING.

Referenced by addTargetToGroupList(), addTargetToSortList(), buildMergedJoinVar(), coerce_to_common_type(), coerce_to_target_type(), coerce_type(), jsonb_subscript_transform(), make_fn_arguments(), ParseFuncOrColumn(), resolveTargetListUnknowns(), transformArrayExpr(), transformForPortionOfClause(), and unify_hypothetical_args().

coerce_type_typmod()

static Node * coerce_type_typmod ( Node *  node, Oid  targetTypeId, int32  targetTypMod, CoercionContext  ccontext, CoercionForm  cformat, int  location, bool  hideInputCoercion  )

static

Definition at line 752 of file parse_coerce.c.

{
    CoercionPathType pathtype;
    Oid         funcId;
 
    /* Skip coercion if already done */
    if (targetTypMod == exprTypmod(node))
        return node;
 
    /* Suppress display of nested coercion steps */
    if (hideInputCoercion)
        hide_coercion_node(node);
 
    /*
     * A negative typmod means that no actual coercion is needed, but we still
     * want a RelabelType to ensure that the expression exposes the intended
     * typmod.
     */
    if (targetTypMod < 0)
        pathtype = COERCION_PATH_NONE;
    else
        pathtype = find_typmod_coercion_function(targetTypeId, &funcId);
 
    if (pathtype != COERCION_PATH_NONE)
    {
        node = build_coercion_expression(node, pathtype, funcId,
                                         targetTypeId, targetTypMod,
                                         ccontext, cformat, location);
    }
    else
    {
        /*
         * We don't need to perform any actual coercion step, but we should
         * apply a RelabelType to ensure that the expression exposes the
         * intended typmod.
         */
        node = applyRelabelType(node, targetTypeId, targetTypMod,
                                exprCollation(node),
                                cformat, location, false);
    }
 
    return node;
}

References applyRelabelType(), build_coercion_expression(), COERCION_PATH_NONE, exprCollation(), exprTypmod(), fb(), find_typmod_coercion_function(), and hide_coercion_node().

Referenced by coerce_to_domain(), and coerce_to_target_type().

enforce_generic_type_consistency()

Oid enforce_generic_type_consistency	(	const Oid *	actual_arg_types,
		Oid *	declared_arg_types,
		int	nargs,
		Oid	rettype,
		bool	allow_poly
	)

Definition at line 2131 of file parse_coerce.c.

{
    bool        have_poly_anycompatible = false;
    bool        have_poly_unknowns = false;
    Oid         elem_typeid = InvalidOid;
    Oid         array_typeid = InvalidOid;
    Oid         range_typeid = InvalidOid;
    Oid         multirange_typeid = InvalidOid;
    Oid         anycompatible_typeid = InvalidOid;
    Oid         anycompatible_array_typeid = InvalidOid;
    Oid         anycompatible_range_typeid = InvalidOid;
    Oid         anycompatible_range_typelem = InvalidOid;
    Oid         anycompatible_multirange_typeid = InvalidOid;
    Oid         anycompatible_multirange_typelem = InvalidOid;
    bool        have_anynonarray = (rettype == ANYNONARRAYOID);
    bool        have_anyenum = (rettype == ANYENUMOID);
    bool        have_anymultirange = (rettype == ANYMULTIRANGEOID);
    bool        have_anycompatible_nonarray = (rettype == ANYCOMPATIBLENONARRAYOID);
    bool        have_anycompatible_array = (rettype == ANYCOMPATIBLEARRAYOID);
    bool        have_anycompatible_range = (rettype == ANYCOMPATIBLERANGEOID);
    bool        have_anycompatible_multirange = (rettype == ANYCOMPATIBLEMULTIRANGEOID);
    int         n_poly_args = 0;    /* this counts all family-1 arguments */
    int         n_anycompatible_args = 0;   /* this counts only non-unknowns */
    Oid         anycompatible_actual_types[FUNC_MAX_ARGS];
 
    /*
     * Loop through the arguments to see if we have any that are polymorphic.
     * If so, require the actual types to be consistent.
     */
    Assert(nargs <= FUNC_MAX_ARGS);
    for (int j = 0; j < nargs; j++)
    {
        Oid         decl_type = declared_arg_types[j];
        Oid         actual_type = actual_arg_types[j];
 
        if (decl_type == ANYELEMENTOID ||
            decl_type == ANYNONARRAYOID ||
            decl_type == ANYENUMOID)
        {
            n_poly_args++;
            if (decl_type == ANYNONARRAYOID)
                have_anynonarray = true;
            else if (decl_type == ANYENUMOID)
                have_anyenum = true;
            if (actual_type == UNKNOWNOID)
            {
                have_poly_unknowns = true;
                continue;
            }
            if (allow_poly && decl_type == actual_type)
                continue;       /* no new information here */
            if (OidIsValid(elem_typeid) && actual_type != elem_typeid)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("arguments declared \"%s\" are not all alike", "anyelement"),
                         errdetail("%s versus %s",
                                   format_type_be(elem_typeid),
                                   format_type_be(actual_type))));
            elem_typeid = actual_type;
        }
        else if (decl_type == ANYARRAYOID)
        {
            n_poly_args++;
            if (actual_type == UNKNOWNOID)
            {
                have_poly_unknowns = true;
                continue;
            }
            if (allow_poly && decl_type == actual_type)
                continue;       /* no new information here */
            actual_type = getBaseType(actual_type); /* flatten domains */
            if (OidIsValid(array_typeid) && actual_type != array_typeid)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("arguments declared \"%s\" are not all alike", "anyarray"),
                         errdetail("%s versus %s",
                                   format_type_be(array_typeid),
                                   format_type_be(actual_type))));
            array_typeid = actual_type;
        }
        else if (decl_type == ANYRANGEOID)
        {
            n_poly_args++;
            if (actual_type == UNKNOWNOID)
            {
                have_poly_unknowns = true;
                continue;
            }
            if (allow_poly && decl_type == actual_type)
                continue;       /* no new information here */
            actual_type = getBaseType(actual_type); /* flatten domains */
            if (OidIsValid(range_typeid) && actual_type != range_typeid)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("arguments declared \"%s\" are not all alike", "anyrange"),
                         errdetail("%s versus %s",
                                   format_type_be(range_typeid),
                                   format_type_be(actual_type))));
            range_typeid = actual_type;
        }
        else if (decl_type == ANYMULTIRANGEOID)
        {
            n_poly_args++;
            have_anymultirange = true;
            if (actual_type == UNKNOWNOID)
            {
                have_poly_unknowns = true;
                continue;
            }
            if (allow_poly && decl_type == actual_type)
                continue;       /* no new information here */
            actual_type = getBaseType(actual_type); /* flatten domains */
            if (OidIsValid(multirange_typeid) && actual_type != multirange_typeid)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("arguments declared \"%s\" are not all alike", "anymultirange"),
                         errdetail("%s versus %s",
                                   format_type_be(multirange_typeid),
                                   format_type_be(actual_type))));
            multirange_typeid = actual_type;
        }
        else if (decl_type == ANYCOMPATIBLEOID ||
                 decl_type == ANYCOMPATIBLENONARRAYOID)
        {
            have_poly_anycompatible = true;
            if (decl_type == ANYCOMPATIBLENONARRAYOID)
                have_anycompatible_nonarray = true;
            if (actual_type == UNKNOWNOID)
                continue;
            if (allow_poly && decl_type == actual_type)
                continue;       /* no new information here */
            /* collect the actual types of non-unknown COMPATIBLE args */
            anycompatible_actual_types[n_anycompatible_args++] = actual_type;
        }
        else if (decl_type == ANYCOMPATIBLEARRAYOID)
        {
            Oid         anycompatible_elem_type;
 
            have_poly_anycompatible = true;
            have_anycompatible_array = true;
            if (actual_type == UNKNOWNOID)
                continue;
            if (allow_poly && decl_type == actual_type)
                continue;       /* no new information here */
            actual_type = getBaseType(actual_type); /* flatten domains */
            anycompatible_elem_type = get_element_type(actual_type);
            if (!OidIsValid(anycompatible_elem_type))
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("argument declared %s is not an array but type %s",
                                "anycompatiblearray",
                                format_type_be(actual_type))));
            /* collect the element type for common-supertype choice */
            anycompatible_actual_types[n_anycompatible_args++] = anycompatible_elem_type;
        }
        else if (decl_type == ANYCOMPATIBLERANGEOID)
        {
            have_poly_anycompatible = true;
            have_anycompatible_range = true;
            if (actual_type == UNKNOWNOID)
                continue;
            if (allow_poly && decl_type == actual_type)
                continue;       /* no new information here */
            actual_type = getBaseType(actual_type); /* flatten domains */
            if (OidIsValid(anycompatible_range_typeid))
            {
                /* All ANYCOMPATIBLERANGE arguments must be the same type */
                if (anycompatible_range_typeid != actual_type)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("arguments declared \"%s\" are not all alike", "anycompatiblerange"),
                             errdetail("%s versus %s",
                                       format_type_be(anycompatible_range_typeid),
                                       format_type_be(actual_type))));
            }
            else
            {
                anycompatible_range_typeid = actual_type;
                anycompatible_range_typelem = get_range_subtype(actual_type);
                if (!OidIsValid(anycompatible_range_typelem))
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("argument declared %s is not a range type but type %s",
                                    "anycompatiblerange",
                                    format_type_be(actual_type))));
                /* collect the subtype for common-supertype choice */
                anycompatible_actual_types[n_anycompatible_args++] = anycompatible_range_typelem;
            }
        }
        else if (decl_type == ANYCOMPATIBLEMULTIRANGEOID)
        {
            have_poly_anycompatible = true;
            have_anycompatible_multirange = true;
            if (actual_type == UNKNOWNOID)
                continue;
            if (allow_poly && decl_type == actual_type)
                continue;       /* no new information here */
            actual_type = getBaseType(actual_type); /* flatten domains */
            if (OidIsValid(anycompatible_multirange_typeid))
            {
                /* All ANYCOMPATIBLEMULTIRANGE arguments must be the same type */
                if (anycompatible_multirange_typeid != actual_type)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("arguments declared \"%s\" are not all alike", "anycompatiblemultirange"),
                             errdetail("%s versus %s",
                                       format_type_be(anycompatible_multirange_typeid),
                                       format_type_be(actual_type))));
            }
            else
            {
                anycompatible_multirange_typeid = actual_type;
                anycompatible_multirange_typelem = get_multirange_range(actual_type);
                if (!OidIsValid(anycompatible_multirange_typelem))
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("argument declared %s is not a multirange type but type %s",
                                    "anycompatiblemultirange",
                                    format_type_be(actual_type))));
                /* we'll consider the subtype below */
            }
        }
    }
 
    /*
     * Fast Track: if none of the arguments are polymorphic, return the
     * unmodified rettype.  Not our job to resolve it if it's polymorphic.
     */
    if (n_poly_args == 0 && !have_poly_anycompatible)
        return rettype;
 
    /* Check matching of family-1 polymorphic arguments, if any */
    if (n_poly_args)
    {
        /* Get the element type based on the array type, if we have one */
        if (OidIsValid(array_typeid))
        {
            Oid         array_typelem;
 
            if (array_typeid == ANYARRAYOID)
            {
                /*
                 * Special case for matching ANYARRAY input to an ANYARRAY
                 * argument: allow it iff no other arguments are family-1
                 * polymorphics (otherwise we couldn't be sure whether the
                 * array element type matches up) and the result type doesn't
                 * require us to infer a specific element type.
                 */
                if (n_poly_args != 1 ||
                    (rettype != ANYARRAYOID &&
                     IsPolymorphicTypeFamily1(rettype)))
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("cannot determine element type of \"anyarray\" argument")));
                array_typelem = ANYELEMENTOID;
            }
            else
            {
                array_typelem = get_element_type(array_typeid);
                if (!OidIsValid(array_typelem))
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("argument declared %s is not an array but type %s",
                                    "anyarray", format_type_be(array_typeid))));
            }
 
            if (!OidIsValid(elem_typeid))
            {
                /*
                 * if we don't have an element type yet, use the one we just
                 * got
                 */
                elem_typeid = array_typelem;
            }
            else if (array_typelem != elem_typeid)
            {
                /* otherwise, they better match */
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("argument declared %s is not consistent with argument declared %s",
                                "anyarray", "anyelement"),
                         errdetail("%s versus %s",
                                   format_type_be(array_typeid),
                                   format_type_be(elem_typeid))));
            }
        }
 
        /* Deduce range type from multirange type, or vice versa */
        if (OidIsValid(multirange_typeid))
        {
            Oid         multirange_typelem;
 
            multirange_typelem = get_multirange_range(multirange_typeid);
            if (!OidIsValid(multirange_typelem))
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("argument declared %s is not a multirange type but type %s",
                                "anymultirange",
                                format_type_be(multirange_typeid))));
 
            if (!OidIsValid(range_typeid))
            {
                /* if we don't have a range type yet, use the one we just got */
                range_typeid = multirange_typelem;
            }
            else if (multirange_typelem != range_typeid)
            {
                /* otherwise, they better match */
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("argument declared %s is not consistent with argument declared %s",
                                "anymultirange", "anyrange"),
                         errdetail("%s versus %s",
                                   format_type_be(multirange_typeid),
                                   format_type_be(range_typeid))));
            }
        }
        else if (have_anymultirange && OidIsValid(range_typeid))
        {
            multirange_typeid = get_range_multirange(range_typeid);
            /* We'll complain below if that didn't work */
        }
 
        /* Get the element type based on the range type, if we have one */
        if (OidIsValid(range_typeid))
        {
            Oid         range_typelem;
 
            range_typelem = get_range_subtype(range_typeid);
            if (!OidIsValid(range_typelem))
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("argument declared %s is not a range type but type %s",
                                "anyrange",
                                format_type_be(range_typeid))));
 
            if (!OidIsValid(elem_typeid))
            {
                /*
                 * if we don't have an element type yet, use the one we just
                 * got
                 */
                elem_typeid = range_typelem;
            }
            else if (range_typelem != elem_typeid)
            {
                /* otherwise, they better match */
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("argument declared %s is not consistent with argument declared %s",
                                "anyrange", "anyelement"),
                         errdetail("%s versus %s",
                                   format_type_be(range_typeid),
                                   format_type_be(elem_typeid))));
            }
        }
 
        if (!OidIsValid(elem_typeid))
        {
            if (allow_poly)
            {
                elem_typeid = ANYELEMENTOID;
                array_typeid = ANYARRAYOID;
                range_typeid = ANYRANGEOID;
                multirange_typeid = ANYMULTIRANGEOID;
            }
            else
            {
                /*
                 * Only way to get here is if all the family-1 polymorphic
                 * arguments have UNKNOWN inputs.
                 */
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("could not determine polymorphic type because input has type %s",
                                "unknown")));
            }
        }
 
        if (have_anynonarray && elem_typeid != ANYELEMENTOID)
        {
            /*
             * require the element type to not be an array or domain over
             * array
             */
            if (type_is_array_domain(elem_typeid))
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("type matched to anynonarray is an array type: %s",
                                format_type_be(elem_typeid))));
        }
 
        if (have_anyenum && elem_typeid != ANYELEMENTOID)
        {
            /* require the element type to be an enum */
            if (!type_is_enum(elem_typeid))
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("type matched to anyenum is not an enum type: %s",
                                format_type_be(elem_typeid))));
        }
    }
 
    /* Check matching of family-2 polymorphic arguments, if any */
    if (have_poly_anycompatible)
    {
        /* Deduce range type from multirange type, or vice versa */
        if (OidIsValid(anycompatible_multirange_typeid))
        {
            if (OidIsValid(anycompatible_range_typeid))
            {
                if (anycompatible_multirange_typelem !=
                    anycompatible_range_typeid)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("argument declared %s is not consistent with argument declared %s",
                                    "anycompatiblemultirange",
                                    "anycompatiblerange"),
                             errdetail("%s versus %s",
                                       format_type_be(anycompatible_multirange_typeid),
                                       format_type_be(anycompatible_range_typeid))));
            }
            else
            {
                anycompatible_range_typeid = anycompatible_multirange_typelem;
                anycompatible_range_typelem = get_range_subtype(anycompatible_range_typeid);
                if (!OidIsValid(anycompatible_range_typelem))
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("argument declared %s is not a multirange type but type %s",
                                    "anycompatiblemultirange",
                                    format_type_be(anycompatible_multirange_typeid))));
                /* this enables element type matching check below */
                have_anycompatible_range = true;
                /* collect the subtype for common-supertype choice */
                anycompatible_actual_types[n_anycompatible_args++] =
                    anycompatible_range_typelem;
            }
        }
        else if (have_anycompatible_multirange &&
                 OidIsValid(anycompatible_range_typeid))
        {
            anycompatible_multirange_typeid = get_range_multirange(anycompatible_range_typeid);
            /* We'll complain below if that didn't work */
        }
 
        if (n_anycompatible_args > 0)
        {
            anycompatible_typeid =
                select_common_type_from_oids(n_anycompatible_args,
                                             anycompatible_actual_types,
                                             false);
 
            /* We have to verify that the selected type actually works */
            if (!verify_common_type_from_oids(anycompatible_typeid,
                                              n_anycompatible_args,
                                              anycompatible_actual_types))
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("arguments of anycompatible family cannot be cast to a common type")));
 
            if (have_anycompatible_array)
            {
                anycompatible_array_typeid = get_array_type(anycompatible_typeid);
                if (!OidIsValid(anycompatible_array_typeid))
                    ereport(ERROR,
                            (errcode(ERRCODE_UNDEFINED_OBJECT),
                             errmsg("could not find array type for data type %s",
                                    format_type_be(anycompatible_typeid))));
            }
 
            if (have_anycompatible_range)
            {
                /* we can't infer a range type from the others */
                if (!OidIsValid(anycompatible_range_typeid))
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("could not determine polymorphic type %s because input has type %s",
                                    "anycompatiblerange", "unknown")));
 
                /*
                 * the anycompatible type must exactly match the range element
                 * type
                 */
                if (anycompatible_range_typelem != anycompatible_typeid)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("anycompatiblerange type %s does not match anycompatible type %s",
                                    format_type_be(anycompatible_range_typeid),
                                    format_type_be(anycompatible_typeid))));
            }
 
            if (have_anycompatible_multirange)
            {
                /* we can't infer a multirange type from the others */
                if (!OidIsValid(anycompatible_multirange_typeid))
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("could not determine polymorphic type %s because input has type %s",
                                    "anycompatiblemultirange", "unknown")));
 
                /*
                 * the anycompatible type must exactly match the multirange
                 * element type
                 */
                if (anycompatible_range_typelem != anycompatible_typeid)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("anycompatiblemultirange type %s does not match anycompatible type %s",
                                    format_type_be(anycompatible_multirange_typeid),
                                    format_type_be(anycompatible_typeid))));
            }
 
            if (have_anycompatible_nonarray)
            {
                /*
                 * require the element type to not be an array or domain over
                 * array
                 */
                if (type_is_array_domain(anycompatible_typeid))
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("type matched to anycompatiblenonarray is an array type: %s",
                                    format_type_be(anycompatible_typeid))));
            }
        }
        else
        {
            if (allow_poly)
            {
                anycompatible_typeid = ANYCOMPATIBLEOID;
                anycompatible_array_typeid = ANYCOMPATIBLEARRAYOID;
                anycompatible_range_typeid = ANYCOMPATIBLERANGEOID;
                anycompatible_multirange_typeid = ANYCOMPATIBLEMULTIRANGEOID;
            }
            else
            {
                /*
                 * Only way to get here is if all the family-2 polymorphic
                 * arguments have UNKNOWN inputs.  Resolve to TEXT as
                 * select_common_type() would do.  That doesn't license us to
                 * use TEXTRANGE or TEXTMULTIRANGE, though.
                 */
                anycompatible_typeid = TEXTOID;
                anycompatible_array_typeid = TEXTARRAYOID;
                if (have_anycompatible_range)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("could not determine polymorphic type %s because input has type %s",
                                    "anycompatiblerange", "unknown")));
                if (have_anycompatible_multirange)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("could not determine polymorphic type %s because input has type %s",
                                    "anycompatiblemultirange", "unknown")));
            }
        }
 
        /* replace family-2 polymorphic types by selected types */
        for (int j = 0; j < nargs; j++)
        {
            Oid         decl_type = declared_arg_types[j];
 
            if (decl_type == ANYCOMPATIBLEOID ||
                decl_type == ANYCOMPATIBLENONARRAYOID)
                declared_arg_types[j] = anycompatible_typeid;
            else if (decl_type == ANYCOMPATIBLEARRAYOID)
                declared_arg_types[j] = anycompatible_array_typeid;
            else if (decl_type == ANYCOMPATIBLERANGEOID)
                declared_arg_types[j] = anycompatible_range_typeid;
            else if (decl_type == ANYCOMPATIBLEMULTIRANGEOID)
                declared_arg_types[j] = anycompatible_multirange_typeid;
        }
    }
 
    /*
     * If we had any UNKNOWN inputs for family-1 polymorphic arguments,
     * re-scan to assign correct types to them.
     *
     * Note: we don't have to consider unknown inputs that were matched to
     * family-2 polymorphic arguments, because we forcibly updated their
     * declared_arg_types[] positions just above.
     */
    if (have_poly_unknowns)
    {
        for (int j = 0; j < nargs; j++)
        {
            Oid         decl_type = declared_arg_types[j];
            Oid         actual_type = actual_arg_types[j];
 
            if (actual_type != UNKNOWNOID)
                continue;
 
            if (decl_type == ANYELEMENTOID ||
                decl_type == ANYNONARRAYOID ||
                decl_type == ANYENUMOID)
                declared_arg_types[j] = elem_typeid;
            else if (decl_type == ANYARRAYOID)
            {
                if (!OidIsValid(array_typeid))
                {
                    array_typeid = get_array_type(elem_typeid);
                    if (!OidIsValid(array_typeid))
                        ereport(ERROR,
                                (errcode(ERRCODE_UNDEFINED_OBJECT),
                                 errmsg("could not find array type for data type %s",
                                        format_type_be(elem_typeid))));
                }
                declared_arg_types[j] = array_typeid;
            }
            else if (decl_type == ANYRANGEOID)
            {
                if (!OidIsValid(range_typeid))
                {
                    /* we can't infer a range type from the others */
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("could not determine polymorphic type %s because input has type %s",
                                    "anyrange", "unknown")));
                }
                declared_arg_types[j] = range_typeid;
            }
            else if (decl_type == ANYMULTIRANGEOID)
            {
                if (!OidIsValid(multirange_typeid))
                {
                    /* we can't infer a multirange type from the others */
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("could not determine polymorphic type %s because input has type %s",
                                    "anymultirange", "unknown")));
                }
                declared_arg_types[j] = multirange_typeid;
            }
        }
    }
 
    /* if we return ANYELEMENT use the appropriate argument type */
    if (rettype == ANYELEMENTOID ||
        rettype == ANYNONARRAYOID ||
        rettype == ANYENUMOID)
        return elem_typeid;
 
    /* if we return ANYARRAY use the appropriate argument type */
    if (rettype == ANYARRAYOID)
    {
        if (!OidIsValid(array_typeid))
        {
            array_typeid = get_array_type(elem_typeid);
            if (!OidIsValid(array_typeid))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("could not find array type for data type %s",
                                format_type_be(elem_typeid))));
        }
        return array_typeid;
    }
 
    /* if we return ANYRANGE use the appropriate argument type */
    if (rettype == ANYRANGEOID)
    {
        /* this error is unreachable if the function signature is valid: */
        if (!OidIsValid(range_typeid))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg_internal("could not determine polymorphic type %s because input has type %s",
                                     "anyrange", "unknown")));
        return range_typeid;
    }
 
    /* if we return ANYMULTIRANGE use the appropriate argument type */
    if (rettype == ANYMULTIRANGEOID)
    {
        /* this error is unreachable if the function signature is valid: */
        if (!OidIsValid(multirange_typeid))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg_internal("could not determine polymorphic type %s because input has type %s",
                                     "anymultirange", "unknown")));
        return multirange_typeid;
    }
 
    /* if we return ANYCOMPATIBLE use the appropriate type */
    if (rettype == ANYCOMPATIBLEOID ||
        rettype == ANYCOMPATIBLENONARRAYOID)
    {
        /* this error is unreachable if the function signature is valid: */
        if (!OidIsValid(anycompatible_typeid))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg_internal("could not identify anycompatible type")));
        return anycompatible_typeid;
    }
 
    /* if we return ANYCOMPATIBLEARRAY use the appropriate type */
    if (rettype == ANYCOMPATIBLEARRAYOID)
    {
        /* this error is unreachable if the function signature is valid: */
        if (!OidIsValid(anycompatible_array_typeid))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg_internal("could not identify anycompatiblearray type")));
        return anycompatible_array_typeid;
    }
 
    /* if we return ANYCOMPATIBLERANGE use the appropriate argument type */
    if (rettype == ANYCOMPATIBLERANGEOID)
    {
        /* this error is unreachable if the function signature is valid: */
        if (!OidIsValid(anycompatible_range_typeid))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg_internal("could not identify anycompatiblerange type")));
        return anycompatible_range_typeid;
    }
 
    /* if we return ANYCOMPATIBLEMULTIRANGE use the appropriate argument type */
    if (rettype == ANYCOMPATIBLEMULTIRANGEOID)
    {
        /* this error is unreachable if the function signature is valid: */
        if (!OidIsValid(anycompatible_multirange_typeid))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg_internal("could not identify anycompatiblemultirange type")));
        return anycompatible_multirange_typeid;
    }
 
    /* we don't return a generic type; send back the original return type */
    return rettype;
}

References Assert, ereport, errcode(), errdetail(), errmsg, errmsg_internal(), ERROR, fb(), format_type_be(), FUNC_MAX_ARGS, get_array_type(), get_element_type(), get_multirange_range(), get_range_multirange(), get_range_subtype(), getBaseType(), InvalidOid, j, OidIsValid, select_common_type_from_oids(), type_is_array_domain, type_is_enum(), and verify_common_type_from_oids().

Referenced by lookup_agg_function(), make_op(), make_scalar_array_op(), ParseFuncOrColumn(), recheck_cast_function_args(), and resolve_aggregate_transtype().

find_coercion_pathway()

CoercionPathType find_coercion_pathway	(	Oid	targetTypeId,
		Oid	sourceTypeId,
		CoercionContext	ccontext,
		Oid *	funcid
	)

Definition at line 3157 of file parse_coerce.c.

{
    CoercionPathType result = COERCION_PATH_NONE;
    HeapTuple   tuple;
 
    *funcid = InvalidOid;
 
    /* Perhaps the types are domains; if so, look at their base types */
    if (OidIsValid(sourceTypeId))
        sourceTypeId = getBaseType(sourceTypeId);
    if (OidIsValid(targetTypeId))
        targetTypeId = getBaseType(targetTypeId);
 
    /* Domains are always coercible to and from their base type */
    if (sourceTypeId == targetTypeId)
        return COERCION_PATH_RELABELTYPE;
 
    /* Look in pg_cast */
    tuple = SearchSysCache2(CASTSOURCETARGET,
                            ObjectIdGetDatum(sourceTypeId),
                            ObjectIdGetDatum(targetTypeId));
 
    if (HeapTupleIsValid(tuple))
    {
        Form_pg_cast castForm = (Form_pg_cast) GETSTRUCT(tuple);
        CoercionContext castcontext;
 
        /* convert char value for castcontext to CoercionContext enum */
        switch (castForm->castcontext)
        {
            case COERCION_CODE_IMPLICIT:
                castcontext = COERCION_IMPLICIT;
                break;
            case COERCION_CODE_ASSIGNMENT:
                castcontext = COERCION_ASSIGNMENT;
                break;
            case COERCION_CODE_EXPLICIT:
                castcontext = COERCION_EXPLICIT;
                break;
            default:
                elog(ERROR, "unrecognized castcontext: %d",
                     (int) castForm->castcontext);
                castcontext = 0;    /* keep compiler quiet */
                break;
        }
 
        /* Rely on ordering of enum for correct behavior here */
        if (ccontext >= castcontext)
        {
            switch (castForm->castmethod)
            {
                case COERCION_METHOD_FUNCTION:
                    result = COERCION_PATH_FUNC;
                    *funcid = castForm->castfunc;
                    break;
                case COERCION_METHOD_INOUT:
                    result = COERCION_PATH_COERCEVIAIO;
                    break;
                case COERCION_METHOD_BINARY:
                    result = COERCION_PATH_RELABELTYPE;
                    break;
                default:
                    elog(ERROR, "unrecognized castmethod: %d",
                         (int) castForm->castmethod);
                    break;
            }
        }
 
        ReleaseSysCache(tuple);
    }
    else
    {
        /*
         * If there's no pg_cast entry, perhaps we are dealing with a pair of
         * array types.  If so, and if their element types have a conversion
         * pathway, report that we can coerce with an ArrayCoerceExpr.
         *
         * Hack: disallow coercions to oidvector and int2vector, which
         * otherwise tend to capture coercions that should go to "real" array
         * types.  We want those types to be considered "real" arrays for many
         * purposes, but not this one.  (Also, ArrayCoerceExpr isn't
         * guaranteed to produce an output that meets the restrictions of
         * these datatypes, such as being 1-dimensional.)
         */
        if (targetTypeId != OIDVECTOROID && targetTypeId != INT2VECTOROID)
        {
            Oid         targetElem;
            Oid         sourceElem;
 
            if ((targetElem = get_element_type(targetTypeId)) != InvalidOid &&
                (sourceElem = get_element_type(sourceTypeId)) != InvalidOid)
            {
                CoercionPathType elempathtype;
                Oid         elemfuncid;
 
                elempathtype = find_coercion_pathway(targetElem,
                                                     sourceElem,
                                                     ccontext,
                                                     &elemfuncid);
                if (elempathtype != COERCION_PATH_NONE)
                {
                    result = COERCION_PATH_ARRAYCOERCE;
                }
            }
        }
 
        /*
         * If we still haven't found a possibility, consider automatic casting
         * using I/O functions.  We allow assignment casts to string types and
         * explicit casts from string types to be handled this way. (The
         * CoerceViaIO mechanism is a lot more general than that, but this is
         * all we want to allow in the absence of a pg_cast entry.) It would
         * probably be better to insist on explicit casts in both directions,
         * but this is a compromise to preserve something of the pre-8.3
         * behavior that many types had implicit (yipes!) casts to text.
         */
        if (result == COERCION_PATH_NONE)
        {
            if (ccontext >= COERCION_ASSIGNMENT &&
                TypeCategory(targetTypeId) == TYPCATEGORY_STRING)
                result = COERCION_PATH_COERCEVIAIO;
            else if (ccontext >= COERCION_EXPLICIT &&
                     TypeCategory(sourceTypeId) == TYPCATEGORY_STRING)
                result = COERCION_PATH_COERCEVIAIO;
        }
    }
 
    /*
     * When parsing PL/pgSQL assignments, allow an I/O cast to be used
     * whenever no normal coercion is available.
     */
    if (result == COERCION_PATH_NONE &&
        ccontext == COERCION_PLPGSQL)
        result = COERCION_PATH_COERCEVIAIO;
 
    return result;
}

References COERCION_ASSIGNMENT, COERCION_EXPLICIT, COERCION_IMPLICIT, COERCION_PATH_ARRAYCOERCE, COERCION_PATH_COERCEVIAIO, COERCION_PATH_FUNC, COERCION_PATH_NONE, COERCION_PATH_RELABELTYPE, COERCION_PLPGSQL, elog, ERROR, fb(), find_coercion_pathway(), Form_pg_cast, get_element_type(), getBaseType(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), result, SearchSysCache2(), and TypeCategory().

Referenced by can_coerce_type(), coerce_type(), find_coercion_pathway(), findFkeyCast(), func_get_detail(), json_categorize_type(), and ri_HashCompareOp().

find_typmod_coercion_function()

CoercionPathType find_typmod_coercion_function	(	Oid	typeId,
		Oid *	funcid
	)

Definition at line 3320 of file parse_coerce.c.

{
    CoercionPathType result;
    Type        targetType;
    Form_pg_type typeForm;
    HeapTuple   tuple;
 
    *funcid = InvalidOid;
    result = COERCION_PATH_FUNC;
 
    targetType = typeidType(typeId);
    typeForm = (Form_pg_type) GETSTRUCT(targetType);
 
    /* Check for a "true" array type */
    if (IsTrueArrayType(typeForm))
    {
        /* Yes, switch our attention to the element type */
        typeId = typeForm->typelem;
        result = COERCION_PATH_ARRAYCOERCE;
    }
    ReleaseSysCache(targetType);
 
    /* Look in pg_cast */
    tuple = SearchSysCache2(CASTSOURCETARGET,
                            ObjectIdGetDatum(typeId),
                            ObjectIdGetDatum(typeId));
 
    if (HeapTupleIsValid(tuple))
    {
        Form_pg_cast castForm = (Form_pg_cast) GETSTRUCT(tuple);
 
        *funcid = castForm->castfunc;
        ReleaseSysCache(tuple);
    }
 
    if (!OidIsValid(*funcid))
        result = COERCION_PATH_NONE;
 
    return result;
}

References COERCION_PATH_ARRAYCOERCE, COERCION_PATH_FUNC, COERCION_PATH_NONE, fb(), Form_pg_cast, Form_pg_type, GETSTRUCT(), HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), result, SearchSysCache2(), and typeidType().

Referenced by coerce_type_typmod().

hide_coercion_node()

static void hide_coercion_node ( Node *  node )

static

Definition at line 810 of file parse_coerce.c.

{
    if (IsA(node, FuncExpr))
        ((FuncExpr *) node)->funcformat = COERCE_IMPLICIT_CAST;
    else if (IsA(node, RelabelType))
        ((RelabelType *) node)->relabelformat = COERCE_IMPLICIT_CAST;
    else if (IsA(node, CoerceViaIO))
        ((CoerceViaIO *) node)->coerceformat = COERCE_IMPLICIT_CAST;
    else if (IsA(node, ArrayCoerceExpr))
        ((ArrayCoerceExpr *) node)->coerceformat = COERCE_IMPLICIT_CAST;
    else if (IsA(node, ConvertRowtypeExpr))
        ((ConvertRowtypeExpr *) node)->convertformat = COERCE_IMPLICIT_CAST;
    else if (IsA(node, RowExpr))
        ((RowExpr *) node)->row_format = COERCE_IMPLICIT_CAST;
    else if (IsA(node, CoerceToDomain))
        ((CoerceToDomain *) node)->coercionformat = COERCE_IMPLICIT_CAST;
    else
        elog(ERROR, "unsupported node type: %d", (int) nodeTag(node));
}

References COERCE_IMPLICIT_CAST, elog, ERROR, fb(), IsA, and nodeTag.

Referenced by coerce_to_domain(), and coerce_type_typmod().

is_complex_array()

static bool is_complex_array ( Oid  typid )

static

Definition at line 3370 of file parse_coerce.c.

{
    Oid         elemtype = get_element_type(typid);
 
    return (OidIsValid(elemtype) && ISCOMPLEX(elemtype));
}

References get_element_type(), ISCOMPLEX, and OidIsValid.

Referenced by can_coerce_type(), coerce_type(), and IsBinaryCoercibleWithCast().

IsBinaryCoercible()

bool IsBinaryCoercible	(	Oid	srctype,
		Oid	targettype
	)

Definition at line 3033 of file parse_coerce.c.

{
    Oid         castoid;
 
    return IsBinaryCoercibleWithCast(srctype, targettype, &castoid);
}

References fb(), and IsBinaryCoercibleWithCast().

Referenced by AggregateCreate(), binary_coercible(), check_amproc_signature(), compatible_oper(), ExecInitAgg(), findRangeSubOpclass(), GetDefaultOpClass(), initialize_peragg(), lookup_agg_function(), ResolveOpClass(), ri_HashCompareOp(), satisfies_hash_partition(), spgGetCache(), ts_stat_sql(), tsvector_update_trigger(), and tupledesc_match().

IsBinaryCoercibleWithCast()

bool IsBinaryCoercibleWithCast	(	Oid	srctype,
		Oid	targettype,
		Oid *	castoid
	)

Definition at line 3049 of file parse_coerce.c.

{
    HeapTuple   tuple;
    Form_pg_cast castForm;
    bool        result;
 
    *castoid = InvalidOid;
 
    /* Fast path if same type */
    if (srctype == targettype)
        return true;
 
    /* Anything is coercible to ANY or ANYELEMENT or ANYCOMPATIBLE */
    if (targettype == ANYOID || targettype == ANYELEMENTOID ||
        targettype == ANYCOMPATIBLEOID)
        return true;
 
    /* If srctype is a domain, reduce to its base type */
    if (OidIsValid(srctype))
        srctype = getBaseType(srctype);
 
    /* Somewhat-fast path for domain -> base type case */
    if (srctype == targettype)
        return true;
 
    /* Also accept any array type as coercible to ANY[COMPATIBLE]ARRAY */
    if (targettype == ANYARRAYOID || targettype == ANYCOMPATIBLEARRAYOID)
        if (type_is_array(srctype))
            return true;
 
    /* Also accept any non-array type as coercible to ANY[COMPATIBLE]NONARRAY */
    if (targettype == ANYNONARRAYOID || targettype == ANYCOMPATIBLENONARRAYOID)
        if (!type_is_array(srctype))
            return true;
 
    /* Also accept any enum type as coercible to ANYENUM */
    if (targettype == ANYENUMOID)
        if (type_is_enum(srctype))
            return true;
 
    /* Also accept any range type as coercible to ANY[COMPATIBLE]RANGE */
    if (targettype == ANYRANGEOID || targettype == ANYCOMPATIBLERANGEOID)
        if (type_is_range(srctype))
            return true;
 
    /* Also, any multirange type is coercible to ANY[COMPATIBLE]MULTIRANGE */
    if (targettype == ANYMULTIRANGEOID || targettype == ANYCOMPATIBLEMULTIRANGEOID)
        if (type_is_multirange(srctype))
            return true;
 
    /* Also accept any composite type as coercible to RECORD */
    if (targettype == RECORDOID)
        if (ISCOMPLEX(srctype))
            return true;
 
    /* Also accept any composite array type as coercible to RECORD[] */
    if (targettype == RECORDARRAYOID)
        if (is_complex_array(srctype))
            return true;
 
    /* Else look in pg_cast */
    tuple = SearchSysCache2(CASTSOURCETARGET,
                            ObjectIdGetDatum(srctype),
                            ObjectIdGetDatum(targettype));
    if (!HeapTupleIsValid(tuple))
        return false;           /* no cast */
    castForm = (Form_pg_cast) GETSTRUCT(tuple);
 
    result = (castForm->castmethod == COERCION_METHOD_BINARY &&
              castForm->castcontext == COERCION_CODE_IMPLICIT);
 
    if (result)
        *castoid = castForm->oid;
 
    ReleaseSysCache(tuple);
 
    return result;
}

References fb(), Form_pg_cast, getBaseType(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, is_complex_array(), ISCOMPLEX, ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), result, SearchSysCache2(), type_is_array, type_is_enum(), type_is_multirange(), and type_is_range().

Referenced by CreateCast(), and IsBinaryCoercible().

IsPreferredType()

bool IsPreferredType	(	TYPCATEGORY	category,
		Oid	type
	)

Definition at line 2997 of file parse_coerce.c.

{
    char        typcategory;
    bool        typispreferred;
 
    get_type_category_preferred(type, &typcategory, &typispreferred);
    if (category == typcategory || category == TYPCATEGORY_INVALID)
        return typispreferred;
    else
        return false;
}

References fb(), get_type_category_preferred(), and type.

Referenced by func_select_candidate(), and GetDefaultOpClass().

parser_coercion_errposition()

int parser_coercion_errposition	(	ParseState *	pstate,
		int	coerce_location,
		Node *	input_expr
	)

Definition at line 1312 of file parse_coerce.c.

{
    if (coerce_location >= 0)
        return parser_errposition(pstate, coerce_location);
    else
        return parser_errposition(pstate, exprLocation(input_expr));
}

References exprLocation(), fb(), and parser_errposition().

Referenced by coerce_record_to_complex(), coerceJsonFuncExpr(), and transformTypeCast().

select_common_type()

Oid select_common_type	(	ParseState *	pstate,
		List *	exprs,
		const char *	context,
		Node **	which_expr
	)

Definition at line 1342 of file parse_coerce.c.

{
    Node       *pexpr;
    Oid         ptype;
    TYPCATEGORY pcategory;
    bool        pispreferred;
    ListCell   *lc;
 
    Assert(exprs != NIL);
    pexpr = (Node *) linitial(exprs);
    lc = list_second_cell(exprs);
    ptype = exprType(pexpr);
 
    /*
     * If all input types are valid and exactly the same, just pick that type.
     * This is the only way that we will resolve the result as being a domain
     * type; otherwise domains are smashed to their base types for comparison.
     */
    if (ptype != UNKNOWNOID)
    {
        for_each_cell(lc, exprs, lc)
        {
            Node       *nexpr = (Node *) lfirst(lc);
            Oid         ntype = exprType(nexpr);
 
            if (ntype != ptype)
                break;
        }
        if (lc == NULL)         /* got to the end of the list? */
        {
            if (which_expr)
                *which_expr = pexpr;
            return ptype;
        }
    }
 
    /*
     * Nope, so set up for the full algorithm.  Note that at this point, lc
     * points to the first list item with type different from pexpr's; we need
     * not re-examine any items the previous loop advanced over.
     */
    ptype = getBaseType(ptype);
    get_type_category_preferred(ptype, &pcategory, &pispreferred);
 
    for_each_cell(lc, exprs, lc)
    {
        Node       *nexpr = (Node *) lfirst(lc);
        Oid         ntype = getBaseType(exprType(nexpr));
 
        /* move on to next one if no new information... */
        if (ntype != UNKNOWNOID && ntype != ptype)
        {
            TYPCATEGORY ncategory;
            bool        nispreferred;
 
            get_type_category_preferred(ntype, &ncategory, &nispreferred);
            if (ptype == UNKNOWNOID)
            {
                /* so far, only unknowns so take anything... */
                pexpr = nexpr;
                ptype = ntype;
                pcategory = ncategory;
                pispreferred = nispreferred;
            }
            else if (ncategory != pcategory)
            {
                /*
                 * both types in different categories? then not much hope...
                 */
                if (context == NULL)
                    return InvalidOid;
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                /*------
                  translator: first %s is name of a SQL construct, eg CASE */
                         errmsg("%s types %s and %s cannot be matched",
                                context,
                                format_type_be(ptype),
                                format_type_be(ntype)),
                         parser_errposition(pstate, exprLocation(nexpr))));
            }
            else if (!pispreferred &&
                     can_coerce_type(1, &ptype, &ntype, COERCION_IMPLICIT) &&
                     !can_coerce_type(1, &ntype, &ptype, COERCION_IMPLICIT))
            {
                /*
                 * take new type if can coerce to it implicitly but not the
                 * other way; but if we have a preferred type, stay on it.
                 */
                pexpr = nexpr;
                ptype = ntype;
                pcategory = ncategory;
                pispreferred = nispreferred;
            }
        }
    }
 
    /*
     * If all the inputs were UNKNOWN type --- ie, unknown-type literals ---
     * then resolve as type TEXT.  This situation comes up with constructs
     * like SELECT (CASE WHEN foo THEN 'bar' ELSE 'baz' END); SELECT 'foo'
     * UNION SELECT 'bar'; It might seem desirable to leave the construct's
     * output type as UNKNOWN, but that really doesn't work, because we'd
     * probably end up needing a runtime coercion from UNKNOWN to something
     * else, and we usually won't have it.  We need to coerce the unknown
     * literals while they are still literals, so a decision has to be made
     * now.
     */
    if (ptype == UNKNOWNOID)
        ptype = TEXTOID;
 
    if (which_expr)
        *which_expr = pexpr;
    return ptype;
}

References Assert, can_coerce_type(), COERCION_IMPLICIT, ereport, errcode(), errmsg, ERROR, exprLocation(), exprType(), fb(), for_each_cell, format_type_be(), get_type_category_preferred(), getBaseType(), InvalidOid, lfirst, linitial, list_second_cell(), NIL, and parser_errposition().

Referenced by analyzeCTE(), buildMergedJoinVar(), constructSetOpTargetlist(), transformAExprIn(), transformArrayExpr(), transformCaseExpr(), transformCoalesceExpr(), transformMinMaxExpr(), transformValuesClause(), and unify_hypothetical_args().

select_common_type_from_oids()

static Oid select_common_type_from_oids ( int  nargs, const Oid *  typeids, bool  noerror  )

static

Definition at line 1478 of file parse_coerce.c.

{
    Oid         ptype;
    TYPCATEGORY pcategory;
    bool        pispreferred;
    int         i = 1;
 
    Assert(nargs > 0);
    ptype = typeids[0];
 
    /* If all input types are valid and exactly the same, pick that type. */
    if (ptype != UNKNOWNOID)
    {
        for (; i < nargs; i++)
        {
            if (typeids[i] != ptype)
                break;
        }
        if (i == nargs)
            return ptype;
    }
 
    /*
     * Nope, so set up for the full algorithm.  Note that at this point, we
     * can skip array entries before "i"; they are all equal to ptype.
     */
    ptype = getBaseType(ptype);
    get_type_category_preferred(ptype, &pcategory, &pispreferred);
 
    for (; i < nargs; i++)
    {
        Oid         ntype = getBaseType(typeids[i]);
 
        /* move on to next one if no new information... */
        if (ntype != UNKNOWNOID && ntype != ptype)
        {
            TYPCATEGORY ncategory;
            bool        nispreferred;
 
            get_type_category_preferred(ntype, &ncategory, &nispreferred);
            if (ptype == UNKNOWNOID)
            {
                /* so far, only unknowns so take anything... */
                ptype = ntype;
                pcategory = ncategory;
                pispreferred = nispreferred;
            }
            else if (ncategory != pcategory)
            {
                /*
                 * both types in different categories? then not much hope...
                 */
                if (noerror)
                    return InvalidOid;
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("argument types %s and %s cannot be matched",
                                format_type_be(ptype),
                                format_type_be(ntype))));
            }
            else if (!pispreferred &&
                     can_coerce_type(1, &ptype, &ntype, COERCION_IMPLICIT) &&
                     !can_coerce_type(1, &ntype, &ptype, COERCION_IMPLICIT))
            {
                /*
                 * take new type if can coerce to it implicitly but not the
                 * other way; but if we have a preferred type, stay on it.
                 */
                ptype = ntype;
                pcategory = ncategory;
                pispreferred = nispreferred;
            }
        }
    }
 
    /* Like select_common_type(), choose TEXT if all inputs were UNKNOWN */
    if (ptype == UNKNOWNOID)
        ptype = TEXTOID;
 
    return ptype;
}

References Assert, can_coerce_type(), COERCION_IMPLICIT, ereport, errcode(), errmsg, ERROR, fb(), format_type_be(), get_type_category_preferred(), getBaseType(), i, and InvalidOid.

Referenced by check_generic_type_consistency(), and enforce_generic_type_consistency().

select_common_typmod()

int32 select_common_typmod	(	ParseState *	pstate,
		List *	exprs,
		Oid	common_type
	)

Definition at line 1644 of file parse_coerce.c.

{
    ListCell   *lc;
    bool        first = true;
    int32       result = -1;
 
    foreach(lc, exprs)
    {
        Node       *expr = (Node *) lfirst(lc);
 
        /* Types must match */
        if (exprType(expr) != common_type)
            return -1;
        else if (first)
        {
            result = exprTypmod(expr);
            first = false;
        }
        else
        {
            /* As soon as we see a non-matching typmod, fall back to -1 */
            if (result != exprTypmod(expr))
                return -1;
        }
    }
 
    return result;
}

References exprType(), exprTypmod(), fb(), lfirst, and result.

Referenced by analyzeCTE(), buildMergedJoinVar(), constructSetOpTargetlist(), transformValuesClause(), and unify_hypothetical_args().

TypeCategory()

TYPCATEGORY TypeCategory

(

Oid

type

)

Definition at line 2977 of file parse_coerce.c.

{
    char        typcategory;
    bool        typispreferred;
 
    get_type_category_preferred(type, &typcategory, &typispreferred);
    Assert(typcategory != TYPCATEGORY_INVALID);
    return (TYPCATEGORY) typcategory;
}

References Assert, fb(), get_type_category_preferred(), and type.

Referenced by find_coercion_pathway(), func_get_detail(), func_select_candidate(), GetDefaultOpClass(), and transformJsonBehavior().

typeIsOfTypedTable()

static bool typeIsOfTypedTable ( Oid  reltypeId, Oid  reloftypeId  )

static

Definition at line 3384 of file parse_coerce.c.

{
    Oid         relid = typeOrDomainTypeRelid(reltypeId);
    bool        result = false;
 
    if (relid)
    {
        HeapTuple   tp;
        Form_pg_class reltup;
 
        tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
        if (!HeapTupleIsValid(tp))
            elog(ERROR, "cache lookup failed for relation %u", relid);
 
        reltup = (Form_pg_class) GETSTRUCT(tp);
        if (reltup->reloftype == reloftypeId)
            result = true;
 
        ReleaseSysCache(tp);
    }
 
    return result;
}

References elog, ERROR, fb(), GETSTRUCT(), HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), result, SearchSysCache1(), and typeOrDomainTypeRelid().

Referenced by can_coerce_type(), and coerce_type().

verify_common_type()

bool verify_common_type	(	Oid	common_type,
		List *	exprs
	)

Definition at line 1606 of file parse_coerce.c.

{
    ListCell   *lc;
 
    foreach(lc, exprs)
    {
        Node       *nexpr = (Node *) lfirst(lc);
        Oid         ntype = exprType(nexpr);
 
        if (!can_coerce_type(1, &ntype, &common_type, COERCION_IMPLICIT))
            return false;
    }
    return true;
}

References can_coerce_type(), COERCION_IMPLICIT, exprType(), fb(), and lfirst.

Referenced by transformAExprIn().

verify_common_type_from_oids()

static bool verify_common_type_from_oids ( Oid  common_type, int  nargs, const Oid *  typeids  )

static

Definition at line 1626 of file parse_coerce.c.

{
    for (int i = 0; i < nargs; i++)
    {
        if (!can_coerce_type(1, &typeids[i], &common_type, COERCION_IMPLICIT))
            return false;
    }
    return true;
}

References can_coerce_type(), COERCION_IMPLICIT, fb(), and i.

Referenced by check_generic_type_consistency(), and enforce_generic_type_consistency().