parse_func.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "catalog/pg_aggregate.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "lib/stringinfo.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_agg.h"
#include "parser/parse_clause.h"
#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
#include "parser/parse_func.h"
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
#include "parser/parse_type.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"

Include dependency graph for parse_func.c:

Go to the source code of this file.

Enumerations
enum	FuncLookupError { FUNCLOOKUP_NOSUCHFUNC , FUNCLOOKUP_AMBIGUOUS }

Functions
static void	unify_hypothetical_args (ParseState *pstate, List *fargs, int numAggregatedArgs, Oid *actual_arg_types, Oid *declared_arg_types)
static Oid	FuncNameAsType (List *funcname)
static Node *	ParseComplexProjection (ParseState *pstate, const char *funcname, Node *first_arg, int location)
static Oid	LookupFuncNameInternal (ObjectType objtype, List *funcname, int nargs, const Oid *argtypes, bool include_out_arguments, bool missing_ok, FuncLookupError *lookupError)
Node *	ParseFuncOrColumn (ParseState *pstate, List *funcname, List *fargs, Node *last_srf, FuncCall *fn, bool proc_call, int location)
int	func_match_argtypes (int nargs, Oid *input_typeids, FuncCandidateList raw_candidates, FuncCandidateList *candidates)
FuncCandidateList	func_select_candidate (int nargs, Oid *input_typeids, FuncCandidateList candidates)
FuncDetailCode	func_get_detail (List *funcname, List *fargs, List *fargnames, int nargs, Oid *argtypes, bool expand_variadic, bool expand_defaults, bool include_out_arguments, Oid *funcid, Oid *rettype, bool *retset, int *nvargs, Oid *vatype, Oid **true_typeids, List **argdefaults)
void	make_fn_arguments (ParseState *pstate, List *fargs, Oid *actual_arg_types, Oid *declared_arg_types)
const char *	funcname_signature_string (const char *funcname, int nargs, List *argnames, const Oid *argtypes)
const char *	func_signature_string (List *funcname, int nargs, List *argnames, const Oid *argtypes)
Oid	LookupFuncName (List *funcname, int nargs, const Oid *argtypes, bool missing_ok)
Oid	LookupFuncWithArgs (ObjectType objtype, ObjectWithArgs *func, bool missing_ok)
void	check_srf_call_placement (ParseState *pstate, Node *last_srf, int location)

Enumeration Type Documentation

FuncLookupError

enum FuncLookupError

Enumerator
FUNCLOOKUP_NOSUCHFUNC
FUNCLOOKUP_AMBIGUOUS

Definition at line 39 of file parse_func.c.

{
    FUNCLOOKUP_NOSUCHFUNC,
    FUNCLOOKUP_AMBIGUOUS,
} FuncLookupError;

Function Documentation

check_srf_call_placement()

void check_srf_call_placement	(	ParseState *	pstate,
		Node *	last_srf,
		int	location
	)

Definition at line 2511 of file parse_func.c.

{
    const char *err;
    bool        errkind;
 
    /*
     * Check to see if the set-returning function is in an invalid place
     * within the query.  Basically, we don't allow SRFs anywhere except in
     * the targetlist (which includes GROUP BY/ORDER BY expressions), VALUES,
     * and functions in FROM.
     *
     * For brevity we support two schemes for reporting an error here: set
     * "err" to a custom message, or set "errkind" true if the error context
     * is sufficiently identified by what ParseExprKindName will return, *and*
     * what it will return is just a SQL keyword.  (Otherwise, use a custom
     * message to avoid creating translation problems.)
     */
    err = NULL;
    errkind = false;
    switch (pstate->p_expr_kind)
    {
        case EXPR_KIND_NONE:
            Assert(false);      /* can't happen */
            break;
        case EXPR_KIND_OTHER:
            /* Accept SRF here; caller must throw error if wanted */
            break;
        case EXPR_KIND_JOIN_ON:
        case EXPR_KIND_JOIN_USING:
            err = _("set-returning functions are not allowed in JOIN conditions");
            break;
        case EXPR_KIND_FROM_SUBSELECT:
            /* can't get here, but just in case, throw an error */
            errkind = true;
            break;
        case EXPR_KIND_FROM_FUNCTION:
            /* okay, but we don't allow nested SRFs here */
            /* errmsg is chosen to match transformRangeFunction() */
            /* errposition should point to the inner SRF */
            if (pstate->p_last_srf != last_srf)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("set-returning functions must appear at top level of FROM"),
                         parser_errposition(pstate,
                                            exprLocation(pstate->p_last_srf))));
            break;
        case EXPR_KIND_WHERE:
            errkind = true;
            break;
        case EXPR_KIND_POLICY:
            err = _("set-returning functions are not allowed in policy expressions");
            break;
        case EXPR_KIND_HAVING:
            errkind = true;
            break;
        case EXPR_KIND_FILTER:
            errkind = true;
            break;
        case EXPR_KIND_WINDOW_PARTITION:
        case EXPR_KIND_WINDOW_ORDER:
            /* okay, these are effectively GROUP BY/ORDER BY */
            pstate->p_hasTargetSRFs = true;
            break;
        case EXPR_KIND_WINDOW_FRAME_RANGE:
        case EXPR_KIND_WINDOW_FRAME_ROWS:
        case EXPR_KIND_WINDOW_FRAME_GROUPS:
            err = _("set-returning functions are not allowed in window definitions");
            break;
        case EXPR_KIND_SELECT_TARGET:
        case EXPR_KIND_INSERT_TARGET:
            /* okay */
            pstate->p_hasTargetSRFs = true;
            break;
        case EXPR_KIND_UPDATE_SOURCE:
        case EXPR_KIND_UPDATE_TARGET:
            /* disallowed because it would be ambiguous what to do */
            errkind = true;
            break;
        case EXPR_KIND_GROUP_BY:
        case EXPR_KIND_ORDER_BY:
            /* okay */
            pstate->p_hasTargetSRFs = true;
            break;
        case EXPR_KIND_DISTINCT_ON:
            /* okay */
            pstate->p_hasTargetSRFs = true;
            break;
        case EXPR_KIND_LIMIT:
        case EXPR_KIND_OFFSET:
            errkind = true;
            break;
        case EXPR_KIND_RETURNING:
        case EXPR_KIND_MERGE_RETURNING:
            errkind = true;
            break;
        case EXPR_KIND_VALUES:
            /* SRFs are presently not supported by nodeValuesscan.c */
            errkind = true;
            break;
        case EXPR_KIND_VALUES_SINGLE:
            /* okay, since we process this like a SELECT tlist */
            pstate->p_hasTargetSRFs = true;
            break;
        case EXPR_KIND_MERGE_WHEN:
            err = _("set-returning functions are not allowed in MERGE WHEN conditions");
            break;
        case EXPR_KIND_CHECK_CONSTRAINT:
        case EXPR_KIND_DOMAIN_CHECK:
            err = _("set-returning functions are not allowed in check constraints");
            break;
        case EXPR_KIND_COLUMN_DEFAULT:
        case EXPR_KIND_FUNCTION_DEFAULT:
            err = _("set-returning functions are not allowed in DEFAULT expressions");
            break;
        case EXPR_KIND_INDEX_EXPRESSION:
            err = _("set-returning functions are not allowed in index expressions");
            break;
        case EXPR_KIND_INDEX_PREDICATE:
            err = _("set-returning functions are not allowed in index predicates");
            break;
        case EXPR_KIND_STATS_EXPRESSION:
            err = _("set-returning functions are not allowed in statistics expressions");
            break;
        case EXPR_KIND_ALTER_COL_TRANSFORM:
            err = _("set-returning functions are not allowed in transform expressions");
            break;
        case EXPR_KIND_EXECUTE_PARAMETER:
            err = _("set-returning functions are not allowed in EXECUTE parameters");
            break;
        case EXPR_KIND_TRIGGER_WHEN:
            err = _("set-returning functions are not allowed in trigger WHEN conditions");
            break;
        case EXPR_KIND_PARTITION_BOUND:
            err = _("set-returning functions are not allowed in partition bound");
            break;
        case EXPR_KIND_PARTITION_EXPRESSION:
            err = _("set-returning functions are not allowed in partition key expressions");
            break;
        case EXPR_KIND_CALL_ARGUMENT:
            err = _("set-returning functions are not allowed in CALL arguments");
            break;
        case EXPR_KIND_COPY_WHERE:
            err = _("set-returning functions are not allowed in COPY FROM WHERE conditions");
            break;
        case EXPR_KIND_GENERATED_COLUMN:
            err = _("set-returning functions are not allowed in column generation expressions");
            break;
        case EXPR_KIND_CYCLE_MARK:
            errkind = true;
            break;
 
            /*
             * There is intentionally no default: case here, so that the
             * compiler will warn if we add a new ParseExprKind without
             * extending this switch.  If we do see an unrecognized value at
             * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
             * which is sane anyway.
             */
    }
    if (err)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg_internal("%s", err),
                 parser_errposition(pstate, location)));
    if (errkind)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /* translator: %s is name of a SQL construct, eg GROUP BY */
                 errmsg("set-returning functions are not allowed in %s",
                        ParseExprKindName(pstate->p_expr_kind)),
                 parser_errposition(pstate, location)));
}

References _, Assert, ereport, err(), errcode(), errmsg(), errmsg_internal(), ERROR, EXPR_KIND_ALTER_COL_TRANSFORM, EXPR_KIND_CALL_ARGUMENT, EXPR_KIND_CHECK_CONSTRAINT, EXPR_KIND_COLUMN_DEFAULT, EXPR_KIND_COPY_WHERE, EXPR_KIND_CYCLE_MARK, EXPR_KIND_DISTINCT_ON, EXPR_KIND_DOMAIN_CHECK, EXPR_KIND_EXECUTE_PARAMETER, EXPR_KIND_FILTER, EXPR_KIND_FROM_FUNCTION, EXPR_KIND_FROM_SUBSELECT, EXPR_KIND_FUNCTION_DEFAULT, EXPR_KIND_GENERATED_COLUMN, EXPR_KIND_GROUP_BY, EXPR_KIND_HAVING, EXPR_KIND_INDEX_EXPRESSION, EXPR_KIND_INDEX_PREDICATE, EXPR_KIND_INSERT_TARGET, EXPR_KIND_JOIN_ON, EXPR_KIND_JOIN_USING, EXPR_KIND_LIMIT, EXPR_KIND_MERGE_RETURNING, EXPR_KIND_MERGE_WHEN, EXPR_KIND_NONE, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, EXPR_KIND_OTHER, EXPR_KIND_PARTITION_BOUND, EXPR_KIND_PARTITION_EXPRESSION, EXPR_KIND_POLICY, EXPR_KIND_RETURNING, EXPR_KIND_SELECT_TARGET, EXPR_KIND_STATS_EXPRESSION, EXPR_KIND_TRIGGER_WHEN, EXPR_KIND_UPDATE_SOURCE, EXPR_KIND_UPDATE_TARGET, EXPR_KIND_VALUES, EXPR_KIND_VALUES_SINGLE, EXPR_KIND_WHERE, EXPR_KIND_WINDOW_FRAME_GROUPS, EXPR_KIND_WINDOW_FRAME_RANGE, EXPR_KIND_WINDOW_FRAME_ROWS, EXPR_KIND_WINDOW_ORDER, EXPR_KIND_WINDOW_PARTITION, exprLocation(), ParseState::p_expr_kind, ParseState::p_hasTargetSRFs, ParseState::p_last_srf, ParseExprKindName(), and parser_errposition().

Referenced by make_op(), and ParseFuncOrColumn().

func_get_detail()

FuncDetailCode func_get_detail	(	List *	funcname,
		List *	fargs,
		List *	fargnames,
		int	nargs,
		Oid *	argtypes,
		bool	expand_variadic,
		bool	expand_defaults,
		bool	include_out_arguments,
		Oid *	funcid,
		Oid *	rettype,
		bool *	retset,
		int *	nvargs,
		Oid *	vatype,
		Oid **	true_typeids,
		List **	argdefaults
	)

Definition at line 1395 of file parse_func.c.

{
    FuncCandidateList raw_candidates;
    FuncCandidateList best_candidate;
 
    /* initialize output arguments to silence compiler warnings */
    *funcid = InvalidOid;
    *rettype = InvalidOid;
    *retset = false;
    *nvargs = 0;
    *vatype = InvalidOid;
    *true_typeids = NULL;
    if (argdefaults)
        *argdefaults = NIL;
 
    /* Get list of possible candidates from namespace search */
    raw_candidates = FuncnameGetCandidates(funcname, nargs, fargnames,
                                           expand_variadic, expand_defaults,
                                           include_out_arguments, false);
 
    /*
     * Quickly check if there is an exact match to the input datatypes (there
     * can be only one)
     */
    for (best_candidate = raw_candidates;
         best_candidate != NULL;
         best_candidate = best_candidate->next)
    {
        /* if nargs==0, argtypes can be null; don't pass that to memcmp */
        if (nargs == 0 ||
            memcmp(argtypes, best_candidate->args, nargs * sizeof(Oid)) == 0)
            break;
    }
 
    if (best_candidate == NULL)
    {
        /*
         * If we didn't find an exact match, next consider the possibility
         * that this is really a type-coercion request: a single-argument
         * function call where the function name is a type name.  If so, and
         * if the coercion path is RELABELTYPE or COERCEVIAIO, then go ahead
         * and treat the "function call" as a coercion.
         *
         * This interpretation needs to be given higher priority than
         * interpretations involving a type coercion followed by a function
         * call, otherwise we can produce surprising results. For example, we
         * want "text(varchar)" to be interpreted as a simple coercion, not as
         * "text(name(varchar))" which the code below this point is entirely
         * capable of selecting.
         *
         * We also treat a coercion of a previously-unknown-type literal
         * constant to a specific type this way.
         *
         * The reason we reject COERCION_PATH_FUNC here is that we expect the
         * cast implementation function to be named after the target type.
         * Thus the function will be found by normal lookup if appropriate.
         *
         * The reason we reject COERCION_PATH_ARRAYCOERCE is mainly that you
         * can't write "foo[] (something)" as a function call.  In theory
         * someone might want to invoke it as "_foo (something)" but we have
         * never supported that historically, so we can insist that people
         * write it as a normal cast instead.
         *
         * We also reject the specific case of COERCEVIAIO for a composite
         * source type and a string-category target type.  This is a case that
         * find_coercion_pathway() allows by default, but experience has shown
         * that it's too commonly invoked by mistake.  So, again, insist that
         * people use cast syntax if they want to do that.
         *
         * NB: it's important that this code does not exceed what coerce_type
         * can do, because the caller will try to apply coerce_type if we
         * return FUNCDETAIL_COERCION.  If we return that result for something
         * coerce_type can't handle, we'll cause infinite recursion between
         * this module and coerce_type!
         */
        if (nargs == 1 && fargs != NIL && fargnames == NIL)
        {
            Oid         targetType = FuncNameAsType(funcname);
 
            if (OidIsValid(targetType))
            {
                Oid         sourceType = argtypes[0];
                Node       *arg1 = linitial(fargs);
                bool        iscoercion;
 
                if (sourceType == UNKNOWNOID && IsA(arg1, Const))
                {
                    /* always treat typename('literal') as coercion */
                    iscoercion = true;
                }
                else
                {
                    CoercionPathType cpathtype;
                    Oid         cfuncid;
 
                    cpathtype = find_coercion_pathway(targetType, sourceType,
                                                      COERCION_EXPLICIT,
                                                      &cfuncid);
                    switch (cpathtype)
                    {
                        case COERCION_PATH_RELABELTYPE:
                            iscoercion = true;
                            break;
                        case COERCION_PATH_COERCEVIAIO:
                            if ((sourceType == RECORDOID ||
                                 ISCOMPLEX(sourceType)) &&
                                TypeCategory(targetType) == TYPCATEGORY_STRING)
                                iscoercion = false;
                            else
                                iscoercion = true;
                            break;
                        default:
                            iscoercion = false;
                            break;
                    }
                }
 
                if (iscoercion)
                {
                    /* Treat it as a type coercion */
                    *funcid = InvalidOid;
                    *rettype = targetType;
                    *retset = false;
                    *nvargs = 0;
                    *vatype = InvalidOid;
                    *true_typeids = argtypes;
                    return FUNCDETAIL_COERCION;
                }
            }
        }
 
        /*
         * didn't find an exact match, so now try to match up candidates...
         */
        if (raw_candidates != NULL)
        {
            FuncCandidateList current_candidates;
            int         ncandidates;
 
            ncandidates = func_match_argtypes(nargs,
                                              argtypes,
                                              raw_candidates,
                                              &current_candidates);
 
            /* one match only? then run with it... */
            if (ncandidates == 1)
                best_candidate = current_candidates;
 
            /*
             * multiple candidates? then better decide or throw an error...
             */
            else if (ncandidates > 1)
            {
                best_candidate = func_select_candidate(nargs,
                                                       argtypes,
                                                       current_candidates);
 
                /*
                 * If we were able to choose a best candidate, we're done.
                 * Otherwise, ambiguous function call.
                 */
                if (!best_candidate)
                    return FUNCDETAIL_MULTIPLE;
            }
        }
    }
 
    if (best_candidate)
    {
        HeapTuple   ftup;
        Form_pg_proc pform;
        FuncDetailCode result;
 
        /*
         * If processing named args or expanding variadics or defaults, the
         * "best candidate" might represent multiple equivalently good
         * functions; treat this case as ambiguous.
         */
        if (!OidIsValid(best_candidate->oid))
            return FUNCDETAIL_MULTIPLE;
 
        /*
         * We disallow VARIADIC with named arguments unless the last argument
         * (the one with VARIADIC attached) actually matched the variadic
         * parameter.  This is mere pedantry, really, but some folks insisted.
         */
        if (fargnames != NIL && !expand_variadic && nargs > 0 &&
            best_candidate->argnumbers[nargs - 1] != nargs - 1)
            return FUNCDETAIL_NOTFOUND;
 
        *funcid = best_candidate->oid;
        *nvargs = best_candidate->nvargs;
        *true_typeids = best_candidate->args;
 
        /*
         * If processing named args, return actual argument positions into
         * NamedArgExpr nodes in the fargs list.  This is a bit ugly but not
         * worth the extra notation needed to do it differently.
         */
        if (best_candidate->argnumbers != NULL)
        {
            int         i = 0;
            ListCell   *lc;
 
            foreach(lc, fargs)
            {
                NamedArgExpr *na = (NamedArgExpr *) lfirst(lc);
 
                if (IsA(na, NamedArgExpr))
                    na->argnumber = best_candidate->argnumbers[i];
                i++;
            }
        }
 
        ftup = SearchSysCache1(PROCOID,
                               ObjectIdGetDatum(best_candidate->oid));
        if (!HeapTupleIsValid(ftup))    /* should not happen */
            elog(ERROR, "cache lookup failed for function %u",
                 best_candidate->oid);
        pform = (Form_pg_proc) GETSTRUCT(ftup);
        *rettype = pform->prorettype;
        *retset = pform->proretset;
        *vatype = pform->provariadic;
        /* fetch default args if caller wants 'em */
        if (argdefaults && best_candidate->ndargs > 0)
        {
            Datum       proargdefaults;
            char       *str;
            List       *defaults;
 
            /* shouldn't happen, FuncnameGetCandidates messed up */
            if (best_candidate->ndargs > pform->pronargdefaults)
                elog(ERROR, "not enough default arguments");
 
            proargdefaults = SysCacheGetAttrNotNull(PROCOID, ftup,
                                                    Anum_pg_proc_proargdefaults);
            str = TextDatumGetCString(proargdefaults);
            defaults = castNode(List, stringToNode(str));
            pfree(str);
 
            /* Delete any unused defaults from the returned list */
            if (best_candidate->argnumbers != NULL)
            {
                /*
                 * This is a bit tricky in named notation, since the supplied
                 * arguments could replace any subset of the defaults.  We
                 * work by making a bitmapset of the argnumbers of defaulted
                 * arguments, then scanning the defaults list and selecting
                 * the needed items.  (This assumes that defaulted arguments
                 * should be supplied in their positional order.)
                 */
                Bitmapset  *defargnumbers;
                int        *firstdefarg;
                List       *newdefaults;
                ListCell   *lc;
                int         i;
 
                defargnumbers = NULL;
                firstdefarg = &best_candidate->argnumbers[best_candidate->nargs - best_candidate->ndargs];
                for (i = 0; i < best_candidate->ndargs; i++)
                    defargnumbers = bms_add_member(defargnumbers,
                                                   firstdefarg[i]);
                newdefaults = NIL;
                i = best_candidate->nominalnargs - pform->pronargdefaults;
                foreach(lc, defaults)
                {
                    if (bms_is_member(i, defargnumbers))
                        newdefaults = lappend(newdefaults, lfirst(lc));
                    i++;
                }
                Assert(list_length(newdefaults) == best_candidate->ndargs);
                bms_free(defargnumbers);
                *argdefaults = newdefaults;
            }
            else
            {
                /*
                 * Defaults for positional notation are lots easier; just
                 * remove any unwanted ones from the front.
                 */
                int         ndelete;
 
                ndelete = list_length(defaults) - best_candidate->ndargs;
                if (ndelete > 0)
                    defaults = list_delete_first_n(defaults, ndelete);
                *argdefaults = defaults;
            }
        }
 
        switch (pform->prokind)
        {
            case PROKIND_AGGREGATE:
                result = FUNCDETAIL_AGGREGATE;
                break;
            case PROKIND_FUNCTION:
                result = FUNCDETAIL_NORMAL;
                break;
            case PROKIND_PROCEDURE:
                result = FUNCDETAIL_PROCEDURE;
                break;
            case PROKIND_WINDOW:
                result = FUNCDETAIL_WINDOWFUNC;
                break;
            default:
                elog(ERROR, "unrecognized prokind: %c", pform->prokind);
                result = FUNCDETAIL_NORMAL; /* keep compiler quiet */
                break;
        }
 
        ReleaseSysCache(ftup);
        return result;
    }
 
    return FUNCDETAIL_NOTFOUND;
}

References NamedArgExpr::argnumber, _FuncCandidateList::argnumbers, _FuncCandidateList::args, Assert, bms_add_member(), bms_free(), bms_is_member(), castNode, COERCION_EXPLICIT, COERCION_PATH_COERCEVIAIO, COERCION_PATH_RELABELTYPE, elog, ERROR, find_coercion_pathway(), func_match_argtypes(), func_select_candidate(), FUNCDETAIL_AGGREGATE, FUNCDETAIL_COERCION, FUNCDETAIL_MULTIPLE, FUNCDETAIL_NORMAL, FUNCDETAIL_NOTFOUND, FUNCDETAIL_PROCEDURE, FUNCDETAIL_WINDOWFUNC, funcname, FuncNameAsType(), FuncnameGetCandidates(), GETSTRUCT, HeapTupleIsValid, i, InvalidOid, IsA, ISCOMPLEX, lappend(), lfirst, linitial, list_delete_first_n(), list_length(), _FuncCandidateList::nargs, _FuncCandidateList::ndargs, _FuncCandidateList::next, NIL, _FuncCandidateList::nominalnargs, _FuncCandidateList::nvargs, ObjectIdGetDatum(), _FuncCandidateList::oid, OidIsValid, pfree(), ReleaseSysCache(), SearchSysCache1(), str, stringToNode(), SysCacheGetAttrNotNull(), TextDatumGetCString, and TypeCategory().

Referenced by generate_function_name(), lookup_agg_function(), and ParseFuncOrColumn().

func_match_argtypes()

int func_match_argtypes	(	int	nargs,
		Oid *	input_typeids,
		FuncCandidateList	raw_candidates,
		FuncCandidateList *	candidates
	)

Definition at line 923 of file parse_func.c.

{
    FuncCandidateList current_candidate;
    FuncCandidateList next_candidate;
    int         ncandidates = 0;
 
    *candidates = NULL;
 
    for (current_candidate = raw_candidates;
         current_candidate != NULL;
         current_candidate = next_candidate)
    {
        next_candidate = current_candidate->next;
        if (can_coerce_type(nargs, input_typeids, current_candidate->args,
                            COERCION_IMPLICIT))
        {
            current_candidate->next = *candidates;
            *candidates = current_candidate;
            ncandidates++;
        }
    }
 
    return ncandidates;
}                               /* func_match_argtypes() */

References _FuncCandidateList::args, can_coerce_type(), COERCION_IMPLICIT, and _FuncCandidateList::next.

Referenced by func_get_detail(), and oper_select_candidate().

func_select_candidate()

FuncCandidateList func_select_candidate	(	int	nargs,
		Oid *	input_typeids,
		FuncCandidateList	candidates
	)

Definition at line 1008 of file parse_func.c.

{
    FuncCandidateList current_candidate,
                first_candidate,
                last_candidate;
    Oid        *current_typeids;
    Oid         current_type;
    int         i;
    int         ncandidates;
    int         nbestMatch,
                nmatch,
                nunknowns;
    Oid         input_base_typeids[FUNC_MAX_ARGS];
    TYPCATEGORY slot_category[FUNC_MAX_ARGS],
                current_category;
    bool        current_is_preferred;
    bool        slot_has_preferred_type[FUNC_MAX_ARGS];
    bool        resolved_unknowns;
 
    /* protect local fixed-size arrays */
    if (nargs > FUNC_MAX_ARGS)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                 errmsg_plural("cannot pass more than %d argument to a function",
                               "cannot pass more than %d arguments to a function",
                               FUNC_MAX_ARGS,
                               FUNC_MAX_ARGS)));
 
    /*
     * If any input types are domains, reduce them to their base types. This
     * ensures that we will consider functions on the base type to be "exact
     * matches" in the exact-match heuristic; it also makes it possible to do
     * something useful with the type-category heuristics. Note that this
     * makes it difficult, but not impossible, to use functions declared to
     * take a domain as an input datatype.  Such a function will be selected
     * over the base-type function only if it is an exact match at all
     * argument positions, and so was already chosen by our caller.
     *
     * While we're at it, count the number of unknown-type arguments for use
     * later.
     */
    nunknowns = 0;
    for (i = 0; i < nargs; i++)
    {
        if (input_typeids[i] != UNKNOWNOID)
            input_base_typeids[i] = getBaseType(input_typeids[i]);
        else
        {
            /* no need to call getBaseType on UNKNOWNOID */
            input_base_typeids[i] = UNKNOWNOID;
            nunknowns++;
        }
    }
 
    /*
     * Run through all candidates and keep those with the most matches on
     * exact types. Keep all candidates if none match.
     */
    ncandidates = 0;
    nbestMatch = 0;
    last_candidate = NULL;
    for (current_candidate = candidates;
         current_candidate != NULL;
         current_candidate = current_candidate->next)
    {
        current_typeids = current_candidate->args;
        nmatch = 0;
        for (i = 0; i < nargs; i++)
        {
            if (input_base_typeids[i] != UNKNOWNOID &&
                current_typeids[i] == input_base_typeids[i])
                nmatch++;
        }
 
        /* take this one as the best choice so far? */
        if ((nmatch > nbestMatch) || (last_candidate == NULL))
        {
            nbestMatch = nmatch;
            candidates = current_candidate;
            last_candidate = current_candidate;
            ncandidates = 1;
        }
        /* no worse than the last choice, so keep this one too? */
        else if (nmatch == nbestMatch)
        {
            last_candidate->next = current_candidate;
            last_candidate = current_candidate;
            ncandidates++;
        }
        /* otherwise, don't bother keeping this one... */
    }
 
    if (last_candidate)         /* terminate rebuilt list */
        last_candidate->next = NULL;
 
    if (ncandidates == 1)
        return candidates;
 
    /*
     * Still too many candidates? Now look for candidates which have either
     * exact matches or preferred types at the args that will require
     * coercion. (Restriction added in 7.4: preferred type must be of same
     * category as input type; give no preference to cross-category
     * conversions to preferred types.)  Keep all candidates if none match.
     */
    for (i = 0; i < nargs; i++) /* avoid multiple lookups */
        slot_category[i] = TypeCategory(input_base_typeids[i]);
    ncandidates = 0;
    nbestMatch = 0;
    last_candidate = NULL;
    for (current_candidate = candidates;
         current_candidate != NULL;
         current_candidate = current_candidate->next)
    {
        current_typeids = current_candidate->args;
        nmatch = 0;
        for (i = 0; i < nargs; i++)
        {
            if (input_base_typeids[i] != UNKNOWNOID)
            {
                if (current_typeids[i] == input_base_typeids[i] ||
                    IsPreferredType(slot_category[i], current_typeids[i]))
                    nmatch++;
            }
        }
 
        if ((nmatch > nbestMatch) || (last_candidate == NULL))
        {
            nbestMatch = nmatch;
            candidates = current_candidate;
            last_candidate = current_candidate;
            ncandidates = 1;
        }
        else if (nmatch == nbestMatch)
        {
            last_candidate->next = current_candidate;
            last_candidate = current_candidate;
            ncandidates++;
        }
    }
 
    if (last_candidate)         /* terminate rebuilt list */
        last_candidate->next = NULL;
 
    if (ncandidates == 1)
        return candidates;
 
    /*
     * Still too many candidates?  Try assigning types for the unknown inputs.
     *
     * If there are no unknown inputs, we have no more heuristics that apply,
     * and must fail.
     */
    if (nunknowns == 0)
        return NULL;            /* failed to select a best candidate */
 
    /*
     * The next step examines each unknown argument position to see if we can
     * determine a "type category" for it.  If any candidate has an input
     * datatype of STRING category, use STRING category (this bias towards
     * STRING is appropriate since unknown-type literals look like strings).
     * Otherwise, if all the candidates agree on the type category of this
     * argument position, use that category.  Otherwise, fail because we
     * cannot determine a category.
     *
     * If we are able to determine a type category, also notice whether any of
     * the candidates takes a preferred datatype within the category.
     *
     * Having completed this examination, remove candidates that accept the
     * wrong category at any unknown position.  Also, if at least one
     * candidate accepted a preferred type at a position, remove candidates
     * that accept non-preferred types.  If just one candidate remains, return
     * that one.  However, if this rule turns out to reject all candidates,
     * keep them all instead.
     */
    resolved_unknowns = false;
    for (i = 0; i < nargs; i++)
    {
        bool        have_conflict;
 
        if (input_base_typeids[i] != UNKNOWNOID)
            continue;
        resolved_unknowns = true;   /* assume we can do it */
        slot_category[i] = TYPCATEGORY_INVALID;
        slot_has_preferred_type[i] = false;
        have_conflict = false;
        for (current_candidate = candidates;
             current_candidate != NULL;
             current_candidate = current_candidate->next)
        {
            current_typeids = current_candidate->args;
            current_type = current_typeids[i];
            get_type_category_preferred(current_type,
                                        &current_category,
                                        &current_is_preferred);
            if (slot_category[i] == TYPCATEGORY_INVALID)
            {
                /* first candidate */
                slot_category[i] = current_category;
                slot_has_preferred_type[i] = current_is_preferred;
            }
            else if (current_category == slot_category[i])
            {
                /* more candidates in same category */
                slot_has_preferred_type[i] |= current_is_preferred;
            }
            else
            {
                /* category conflict! */
                if (current_category == TYPCATEGORY_STRING)
                {
                    /* STRING always wins if available */
                    slot_category[i] = current_category;
                    slot_has_preferred_type[i] = current_is_preferred;
                }
                else
                {
                    /*
                     * Remember conflict, but keep going (might find STRING)
                     */
                    have_conflict = true;
                }
            }
        }
        if (have_conflict && slot_category[i] != TYPCATEGORY_STRING)
        {
            /* Failed to resolve category conflict at this position */
            resolved_unknowns = false;
            break;
        }
    }
 
    if (resolved_unknowns)
    {
        /* Strip non-matching candidates */
        ncandidates = 0;
        first_candidate = candidates;
        last_candidate = NULL;
        for (current_candidate = candidates;
             current_candidate != NULL;
             current_candidate = current_candidate->next)
        {
            bool        keepit = true;
 
            current_typeids = current_candidate->args;
            for (i = 0; i < nargs; i++)
            {
                if (input_base_typeids[i] != UNKNOWNOID)
                    continue;
                current_type = current_typeids[i];
                get_type_category_preferred(current_type,
                                            &current_category,
                                            &current_is_preferred);
                if (current_category != slot_category[i])
                {
                    keepit = false;
                    break;
                }
                if (slot_has_preferred_type[i] && !current_is_preferred)
                {
                    keepit = false;
                    break;
                }
            }
            if (keepit)
            {
                /* keep this candidate */
                last_candidate = current_candidate;
                ncandidates++;
            }
            else
            {
                /* forget this candidate */
                if (last_candidate)
                    last_candidate->next = current_candidate->next;
                else
                    first_candidate = current_candidate->next;
            }
        }
 
        /* if we found any matches, restrict our attention to those */
        if (last_candidate)
        {
            candidates = first_candidate;
            /* terminate rebuilt list */
            last_candidate->next = NULL;
        }
 
        if (ncandidates == 1)
            return candidates;
    }
 
    /*
     * Last gasp: if there are both known- and unknown-type inputs, and all
     * the known types are the same, assume the unknown inputs are also that
     * type, and see if that gives us a unique match.  If so, use that match.
     *
     * NOTE: for a binary operator with one unknown and one non-unknown input,
     * we already tried this heuristic in binary_oper_exact().  However, that
     * code only finds exact matches, whereas here we will handle matches that
     * involve coercion, polymorphic type resolution, etc.
     */
    if (nunknowns < nargs)
    {
        Oid         known_type = UNKNOWNOID;
 
        for (i = 0; i < nargs; i++)
        {
            if (input_base_typeids[i] == UNKNOWNOID)
                continue;
            if (known_type == UNKNOWNOID)   /* first known arg? */
                known_type = input_base_typeids[i];
            else if (known_type != input_base_typeids[i])
            {
                /* oops, not all match */
                known_type = UNKNOWNOID;
                break;
            }
        }
 
        if (known_type != UNKNOWNOID)
        {
            /* okay, just one known type, apply the heuristic */
            for (i = 0; i < nargs; i++)
                input_base_typeids[i] = known_type;
            ncandidates = 0;
            last_candidate = NULL;
            for (current_candidate = candidates;
                 current_candidate != NULL;
                 current_candidate = current_candidate->next)
            {
                current_typeids = current_candidate->args;
                if (can_coerce_type(nargs, input_base_typeids, current_typeids,
                                    COERCION_IMPLICIT))
                {
                    if (++ncandidates > 1)
                        break;  /* not unique, give up */
                    last_candidate = current_candidate;
                }
            }
            if (ncandidates == 1)
            {
                /* successfully identified a unique match */
                last_candidate->next = NULL;
                return last_candidate;
            }
        }
    }
 
    return NULL;                /* failed to select a best candidate */
}                               /* func_select_candidate() */

References _FuncCandidateList::args, can_coerce_type(), COERCION_IMPLICIT, ereport, errcode(), errmsg_plural(), ERROR, FUNC_MAX_ARGS, get_type_category_preferred(), getBaseType(), i, IsPreferredType(), _FuncCandidateList::next, and TypeCategory().

Referenced by func_get_detail(), and oper_select_candidate().

func_signature_string()

const char* func_signature_string	(	List *	funcname,
		int	nargs,
		List *	argnames,
		const Oid *	argtypes
	)

Definition at line 2030 of file parse_func.c.

{
    return funcname_signature_string(NameListToString(funcname),
                                     nargs, argnames, argtypes);
}

References funcname, funcname_signature_string(), and NameListToString().

Referenced by findRangeCanonicalFunction(), findRangeSubtypeDiffFunction(), findTypeAnalyzeFunction(), findTypeInputFunction(), findTypeOutputFunction(), findTypeReceiveFunction(), findTypeSendFunction(), findTypeSubscriptingFunction(), findTypeTypmodinFunction(), findTypeTypmodoutFunction(), get_ts_parser_func(), get_ts_template_func(), interpret_func_support(), lookup_agg_function(), LookupFuncName(), LookupFuncWithArgs(), and ParseFuncOrColumn().

funcname_signature_string()

const char* funcname_signature_string	(	const char *	funcname,
		int	nargs,
		List *	argnames,
		const Oid *	argtypes
	)

Definition at line 1993 of file parse_func.c.

{
    StringInfoData argbuf;
    int         numposargs;
    ListCell   *lc;
    int         i;
 
    initStringInfo(&argbuf);
 
    appendStringInfo(&argbuf, "%s(", funcname);
 
    numposargs = nargs - list_length(argnames);
    lc = list_head(argnames);
 
    for (i = 0; i < nargs; i++)
    {
        if (i)
            appendStringInfoString(&argbuf, ", ");
        if (i >= numposargs)
        {
            appendStringInfo(&argbuf, "%s => ", (char *) lfirst(lc));
            lc = lnext(argnames, lc);
        }
        appendStringInfoString(&argbuf, format_type_be(argtypes[i]));
    }
 
    appendStringInfoChar(&argbuf, ')');
 
    return argbuf.data;         /* return palloc'd string buffer */
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), StringInfoData::data, format_type_be(), funcname, i, initStringInfo(), lfirst, list_head(), list_length(), and lnext().

Referenced by func_signature_string(), and IsThereFunctionInNamespace().

FuncNameAsType()

static Oid FuncNameAsType ( List *  funcname )

static

Definition at line 1881 of file parse_func.c.

{
    Oid         result;
    Type        typtup;
 
    /*
     * temp_ok=false protects the <refsect1 id="sql-createfunction-security">
     * contract for writing SECURITY DEFINER functions safely.
     */
    typtup = LookupTypeNameExtended(NULL, makeTypeNameFromNameList(funcname),
                                    NULL, false, false);
    if (typtup == NULL)
        return InvalidOid;
 
    if (((Form_pg_type) GETSTRUCT(typtup))->typisdefined &&
        !OidIsValid(typeTypeRelid(typtup)))
        result = typeTypeId(typtup);
    else
        result = InvalidOid;
 
    ReleaseSysCache(typtup);
    return result;
}

References funcname, GETSTRUCT, InvalidOid, LookupTypeNameExtended(), makeTypeNameFromNameList(), OidIsValid, ReleaseSysCache(), typeTypeId(), and typeTypeRelid().

Referenced by func_get_detail().

LookupFuncName()

Oid LookupFuncName	(	List *	funcname,
		int	nargs,
		const Oid *	argtypes,
		bool	missing_ok
	)

Definition at line 2144 of file parse_func.c.

{
    Oid         funcoid;
    FuncLookupError lookupError;
 
    funcoid = LookupFuncNameInternal(OBJECT_FUNCTION,
                                     funcname, nargs, argtypes,
                                     false, missing_ok,
                                     &lookupError);
 
    if (OidIsValid(funcoid))
        return funcoid;
 
    switch (lookupError)
    {
        case FUNCLOOKUP_NOSUCHFUNC:
            /* Let the caller deal with it when missing_ok is true */
            if (missing_ok)
                return InvalidOid;
 
            if (nargs < 0)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("could not find a function named \"%s\"",
                                NameListToString(funcname))));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("function %s does not exist",
                                func_signature_string(funcname, nargs,
                                                      NIL, argtypes))));
            break;
 
        case FUNCLOOKUP_AMBIGUOUS:
            /* Raise an error regardless of missing_ok */
            ereport(ERROR,
                    (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                     errmsg("function name \"%s\" is not unique",
                            NameListToString(funcname)),
                     errhint("Specify the argument list to select the function unambiguously.")));
            break;
    }
 
    return InvalidOid;          /* Keep compiler quiet */
}

References ereport, errcode(), errhint(), errmsg(), ERROR, func_signature_string(), FUNCLOOKUP_AMBIGUOUS, FUNCLOOKUP_NOSUCHFUNC, funcname, InvalidOid, LookupFuncNameInternal(), NameListToString(), NIL, OBJECT_FUNCTION, and OidIsValid.

Referenced by call_pltcl_start_proc(), CreateConversionCommand(), CreateEventTrigger(), CreateProceduralLanguage(), CreateTriggerFiringOn(), DefineOperator(), findRangeCanonicalFunction(), findRangeSubtypeDiffFunction(), findTypeAnalyzeFunction(), findTypeInputFunction(), findTypeOutputFunction(), findTypeReceiveFunction(), findTypeSendFunction(), findTypeSubscriptingFunction(), findTypeTypmodinFunction(), findTypeTypmodoutFunction(), get_ts_parser_func(), get_ts_template_func(), interpret_func_support(), lookup_am_handler_func(), lookup_fdw_handler_func(), lookup_fdw_validator_func(), transformRangeTableSample(), ValidateJoinEstimator(), and ValidateRestrictionEstimator().

LookupFuncNameInternal()

static Oid LookupFuncNameInternal ( ObjectType  objtype, List *  funcname, int  nargs, const Oid *  argtypes, bool  include_out_arguments, bool  missing_ok, FuncLookupError *  lookupError  )

static

Definition at line 2049 of file parse_func.c.

{
    Oid         result = InvalidOid;
    FuncCandidateList clist;
 
    /* NULL argtypes allowed for nullary functions only */
    Assert(argtypes != NULL || nargs == 0);
 
    /* Always set *lookupError, to forestall uninitialized-variable warnings */
    *lookupError = FUNCLOOKUP_NOSUCHFUNC;
 
    /* Get list of candidate objects */
    clist = FuncnameGetCandidates(funcname, nargs, NIL, false, false,
                                  include_out_arguments, missing_ok);
 
    /* Scan list for a match to the arg types (if specified) and the objtype */
    for (; clist != NULL; clist = clist->next)
    {
        /* Check arg type match, if specified */
        if (nargs >= 0)
        {
            /* if nargs==0, argtypes can be null; don't pass that to memcmp */
            if (nargs > 0 &&
                memcmp(argtypes, clist->args, nargs * sizeof(Oid)) != 0)
                continue;
        }
 
        /* Check for duplicates reported by FuncnameGetCandidates */
        if (!OidIsValid(clist->oid))
        {
            *lookupError = FUNCLOOKUP_AMBIGUOUS;
            return InvalidOid;
        }
 
        /* Check objtype match, if specified */
        switch (objtype)
        {
            case OBJECT_FUNCTION:
            case OBJECT_AGGREGATE:
                /* Ignore procedures */
                if (get_func_prokind(clist->oid) == PROKIND_PROCEDURE)
                    continue;
                break;
            case OBJECT_PROCEDURE:
                /* Ignore non-procedures */
                if (get_func_prokind(clist->oid) != PROKIND_PROCEDURE)
                    continue;
                break;
            case OBJECT_ROUTINE:
                /* no restriction */
                break;
            default:
                Assert(false);
        }
 
        /* Check for multiple matches */
        if (OidIsValid(result))
        {
            *lookupError = FUNCLOOKUP_AMBIGUOUS;
            return InvalidOid;
        }
 
        /* OK, we have a candidate */
        result = clist->oid;
    }
 
    return result;
}

References _FuncCandidateList::args, Assert, FUNCLOOKUP_AMBIGUOUS, FUNCLOOKUP_NOSUCHFUNC, funcname, FuncnameGetCandidates(), get_func_prokind(), InvalidOid, _FuncCandidateList::next, NIL, OBJECT_AGGREGATE, OBJECT_FUNCTION, OBJECT_PROCEDURE, OBJECT_ROUTINE, _FuncCandidateList::oid, and OidIsValid.

Referenced by LookupFuncName(), and LookupFuncWithArgs().

LookupFuncWithArgs()

Oid LookupFuncWithArgs	(	ObjectType	objtype,
		ObjectWithArgs *	func,
		bool	missing_ok
	)

Definition at line 2206 of file parse_func.c.

{
    Oid         argoids[FUNC_MAX_ARGS];
    int         argcount;
    int         nargs;
    int         i;
    ListCell   *args_item;
    Oid         oid;
    FuncLookupError lookupError;
 
    Assert(objtype == OBJECT_AGGREGATE ||
           objtype == OBJECT_FUNCTION ||
           objtype == OBJECT_PROCEDURE ||
           objtype == OBJECT_ROUTINE);
 
    argcount = list_length(func->objargs);
    if (argcount > FUNC_MAX_ARGS)
    {
        if (objtype == OBJECT_PROCEDURE)
            ereport(ERROR,
                    (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                     errmsg_plural("procedures cannot have more than %d argument",
                                   "procedures cannot have more than %d arguments",
                                   FUNC_MAX_ARGS,
                                   FUNC_MAX_ARGS)));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                     errmsg_plural("functions cannot have more than %d argument",
                                   "functions cannot have more than %d arguments",
                                   FUNC_MAX_ARGS,
                                   FUNC_MAX_ARGS)));
    }
 
    /*
     * First, perform a lookup considering only input arguments (traditional
     * Postgres rules).
     */
    i = 0;
    foreach(args_item, func->objargs)
    {
        TypeName   *t = lfirst_node(TypeName, args_item);
 
        argoids[i] = LookupTypeNameOid(NULL, t, missing_ok);
        if (!OidIsValid(argoids[i]))
            return InvalidOid;  /* missing_ok must be true */
        i++;
    }
 
    /*
     * Set nargs for LookupFuncNameInternal. It expects -1 to mean no args
     * were specified.
     */
    nargs = func->args_unspecified ? -1 : argcount;
 
    /*
     * In args_unspecified mode, also tell LookupFuncNameInternal to consider
     * the object type, since there seems no reason not to.  However, if we
     * have an argument list, disable the objtype check, because we'd rather
     * complain about "object is of wrong type" than "object doesn't exist".
     * (Note that with args, FuncnameGetCandidates will have ensured there's
     * only one argtype match, so we're not risking an ambiguity failure via
     * this choice.)
     */
    oid = LookupFuncNameInternal(func->args_unspecified ? objtype : OBJECT_ROUTINE,
                                 func->objname, nargs, argoids,
                                 false, missing_ok,
                                 &lookupError);
 
    /*
     * If PROCEDURE or ROUTINE was specified, and we have an argument list
     * that contains no parameter mode markers, and we didn't already discover
     * that there's ambiguity, perform a lookup considering all arguments.
     * (Note: for a zero-argument procedure, or in args_unspecified mode, the
     * normal lookup is sufficient; so it's OK to require non-NIL objfuncargs
     * to perform this lookup.)
     */
    if ((objtype == OBJECT_PROCEDURE || objtype == OBJECT_ROUTINE) &&
        func->objfuncargs != NIL &&
        lookupError != FUNCLOOKUP_AMBIGUOUS)
    {
        bool        have_param_mode = false;
 
        /*
         * Check for non-default parameter mode markers.  If there are any,
         * then the command does not conform to SQL-spec syntax, so we may
         * assume that the traditional Postgres lookup method of considering
         * only input parameters is sufficient.  (Note that because the spec
         * doesn't have OUT arguments for functions, we also don't need this
         * hack in FUNCTION or AGGREGATE mode.)
         */
        foreach(args_item, func->objfuncargs)
        {
            FunctionParameter *fp = lfirst_node(FunctionParameter, args_item);
 
            if (fp->mode != FUNC_PARAM_DEFAULT)
            {
                have_param_mode = true;
                break;
            }
        }
 
        if (!have_param_mode)
        {
            Oid         poid;
 
            /* Without mode marks, objargs surely includes all params */
            Assert(list_length(func->objfuncargs) == argcount);
 
            /* For objtype == OBJECT_PROCEDURE, we can ignore non-procedures */
            poid = LookupFuncNameInternal(objtype, func->objname,
                                          argcount, argoids,
                                          true, missing_ok,
                                          &lookupError);
 
            /* Combine results, handling ambiguity */
            if (OidIsValid(poid))
            {
                if (OidIsValid(oid) && oid != poid)
                {
                    /* oops, we got hits both ways, on different objects */
                    oid = InvalidOid;
                    lookupError = FUNCLOOKUP_AMBIGUOUS;
                }
                else
                    oid = poid;
            }
            else if (lookupError == FUNCLOOKUP_AMBIGUOUS)
                oid = InvalidOid;
        }
    }
 
    if (OidIsValid(oid))
    {
        /*
         * Even if we found the function, perform validation that the objtype
         * matches the prokind of the found function.  For historical reasons
         * we allow the objtype of FUNCTION to include aggregates and window
         * functions; but we draw the line if the object is a procedure.  That
         * is a new enough feature that this historical rule does not apply.
         *
         * (This check is partially redundant with the objtype check in
         * LookupFuncNameInternal; but not entirely, since we often don't tell
         * LookupFuncNameInternal to apply that check at all.)
         */
        switch (objtype)
        {
            case OBJECT_FUNCTION:
                /* Only complain if it's a procedure. */
                if (get_func_prokind(oid) == PROKIND_PROCEDURE)
                    ereport(ERROR,
                            (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                             errmsg("%s is not a function",
                                    func_signature_string(func->objname, argcount,
                                                          NIL, argoids))));
                break;
 
            case OBJECT_PROCEDURE:
                /* Reject if found object is not a procedure. */
                if (get_func_prokind(oid) != PROKIND_PROCEDURE)
                    ereport(ERROR,
                            (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                             errmsg("%s is not a procedure",
                                    func_signature_string(func->objname, argcount,
                                                          NIL, argoids))));
                break;
 
            case OBJECT_AGGREGATE:
                /* Reject if found object is not an aggregate. */
                if (get_func_prokind(oid) != PROKIND_AGGREGATE)
                    ereport(ERROR,
                            (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                             errmsg("function %s is not an aggregate",
                                    func_signature_string(func->objname, argcount,
                                                          NIL, argoids))));
                break;
 
            default:
                /* OBJECT_ROUTINE accepts anything. */
                break;
        }
 
        return oid;             /* All good */
    }
    else
    {
        /* Deal with cases where the lookup failed */
        switch (lookupError)
        {
            case FUNCLOOKUP_NOSUCHFUNC:
                /* Suppress no-such-func errors when missing_ok is true */
                if (missing_ok)
                    break;
 
                switch (objtype)
                {
                    case OBJECT_PROCEDURE:
                        if (func->args_unspecified)
                            ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                                     errmsg("could not find a procedure named \"%s\"",
                                            NameListToString(func->objname))));
                        else
                            ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                                     errmsg("procedure %s does not exist",
                                            func_signature_string(func->objname, argcount,
                                                                  NIL, argoids))));
                        break;
 
                    case OBJECT_AGGREGATE:
                        if (func->args_unspecified)
                            ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                                     errmsg("could not find an aggregate named \"%s\"",
                                            NameListToString(func->objname))));
                        else if (argcount == 0)
                            ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                                     errmsg("aggregate %s(*) does not exist",
                                            NameListToString(func->objname))));
                        else
                            ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                                     errmsg("aggregate %s does not exist",
                                            func_signature_string(func->objname, argcount,
                                                                  NIL, argoids))));
                        break;
 
                    default:
                        /* FUNCTION and ROUTINE */
                        if (func->args_unspecified)
                            ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                                     errmsg("could not find a function named \"%s\"",
                                            NameListToString(func->objname))));
                        else
                            ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                                     errmsg("function %s does not exist",
                                            func_signature_string(func->objname, argcount,
                                                                  NIL, argoids))));
                        break;
                }
                break;
 
            case FUNCLOOKUP_AMBIGUOUS:
                switch (objtype)
                {
                    case OBJECT_FUNCTION:
                        ereport(ERROR,
                                (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                                 errmsg("function name \"%s\" is not unique",
                                        NameListToString(func->objname)),
                                 func->args_unspecified ?
                                 errhint("Specify the argument list to select the function unambiguously.") : 0));
                        break;
                    case OBJECT_PROCEDURE:
                        ereport(ERROR,
                                (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                                 errmsg("procedure name \"%s\" is not unique",
                                        NameListToString(func->objname)),
                                 func->args_unspecified ?
                                 errhint("Specify the argument list to select the procedure unambiguously.") : 0));
                        break;
                    case OBJECT_AGGREGATE:
                        ereport(ERROR,
                                (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                                 errmsg("aggregate name \"%s\" is not unique",
                                        NameListToString(func->objname)),
                                 func->args_unspecified ?
                                 errhint("Specify the argument list to select the aggregate unambiguously.") : 0));
                        break;
                    case OBJECT_ROUTINE:
                        ereport(ERROR,
                                (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                                 errmsg("routine name \"%s\" is not unique",
                                        NameListToString(func->objname)),
                                 func->args_unspecified ?
                                 errhint("Specify the argument list to select the routine unambiguously.") : 0));
                        break;
 
                    default:
                        Assert(false);  /* Disallowed by Assert above */
                        break;
                }
                break;
        }
 
        return InvalidOid;
    }
}

References ObjectWithArgs::args_unspecified, Assert, ereport, errcode(), errhint(), errmsg(), errmsg_plural(), ERROR, FUNC_MAX_ARGS, FUNC_PARAM_DEFAULT, func_signature_string(), FUNCLOOKUP_AMBIGUOUS, FUNCLOOKUP_NOSUCHFUNC, get_func_prokind(), i, InvalidOid, lfirst_node, list_length(), LookupFuncNameInternal(), LookupTypeNameOid(), FunctionParameter::mode, NameListToString(), NIL, ObjectWithArgs::objargs, OBJECT_AGGREGATE, OBJECT_FUNCTION, OBJECT_PROCEDURE, OBJECT_ROUTINE, ObjectWithArgs::objfuncargs, ObjectWithArgs::objname, and OidIsValid.

Referenced by AlterFunction(), AlterOpFamilyAdd(), CreateCast(), CreateTransform(), DefineOpClass(), get_object_address(), and objectNamesToOids().

make_fn_arguments()

void make_fn_arguments	(	ParseState *	pstate,
		List *	fargs,
		Oid *	actual_arg_types,
		Oid *	declared_arg_types
	)

Definition at line 1825 of file parse_func.c.

{
    ListCell   *current_fargs;
    int         i = 0;
 
    foreach(current_fargs, fargs)
    {
        /* types don't match? then force coercion using a function call... */
        if (actual_arg_types[i] != declared_arg_types[i])
        {
            Node       *node = (Node *) lfirst(current_fargs);
 
            /*
             * If arg is a NamedArgExpr, coerce its input expr instead --- we
             * want the NamedArgExpr to stay at the top level of the list.
             */
            if (IsA(node, NamedArgExpr))
            {
                NamedArgExpr *na = (NamedArgExpr *) node;
 
                node = coerce_type(pstate,
                                   (Node *) na->arg,
                                   actual_arg_types[i],
                                   declared_arg_types[i], -1,
                                   COERCION_IMPLICIT,
                                   COERCE_IMPLICIT_CAST,
                                   -1);
                na->arg = (Expr *) node;
            }
            else
            {
                node = coerce_type(pstate,
                                   node,
                                   actual_arg_types[i],
                                   declared_arg_types[i], -1,
                                   COERCION_IMPLICIT,
                                   COERCE_IMPLICIT_CAST,
                                   -1);
                lfirst(current_fargs) = node;
            }
        }
        i++;
    }
}

References NamedArgExpr::arg, COERCE_IMPLICIT_CAST, coerce_type(), COERCION_IMPLICIT, i, IsA, and lfirst.

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

ParseComplexProjection()

static Node * ParseComplexProjection ( ParseState *  pstate, const char *  funcname, Node *  first_arg, int  location  )

static

Definition at line 1912 of file parse_func.c.

{
    TupleDesc   tupdesc;
    int         i;
 
    /*
     * Special case for whole-row Vars so that we can resolve (foo.*).bar even
     * when foo is a reference to a subselect, join, or RECORD function. A
     * bonus is that we avoid generating an unnecessary FieldSelect; our
     * result can omit the whole-row Var and just be a Var for the selected
     * field.
     *
     * This case could be handled by expandRecordVariable, but it's more
     * efficient to do it this way when possible.
     */
    if (IsA(first_arg, Var) &&
        ((Var *) first_arg)->varattno == InvalidAttrNumber)
    {
        ParseNamespaceItem *nsitem;
 
        nsitem = GetNSItemByRangeTablePosn(pstate,
                                           ((Var *) first_arg)->varno,
                                           ((Var *) first_arg)->varlevelsup);
        /* Return a Var if funcname matches a column, else NULL */
        return scanNSItemForColumn(pstate, nsitem,
                                   ((Var *) first_arg)->varlevelsup,
                                   funcname, location);
    }
 
    /*
     * Else do it the hard way with get_expr_result_tupdesc().
     *
     * If it's a Var of type RECORD, we have to work even harder: we have to
     * find what the Var refers to, and pass that to get_expr_result_tupdesc.
     * That task is handled by expandRecordVariable().
     */
    if (IsA(first_arg, Var) &&
        ((Var *) first_arg)->vartype == RECORDOID)
        tupdesc = expandRecordVariable(pstate, (Var *) first_arg, 0);
    else
        tupdesc = get_expr_result_tupdesc(first_arg, true);
    if (!tupdesc)
        return NULL;            /* unresolvable RECORD type */
 
    for (i = 0; i < tupdesc->natts; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);
 
        if (strcmp(funcname, NameStr(att->attname)) == 0 &&
            !att->attisdropped)
        {
            /* Success, so generate a FieldSelect expression */
            FieldSelect *fselect = makeNode(FieldSelect);
 
            fselect->arg = (Expr *) first_arg;
            fselect->fieldnum = i + 1;
            fselect->resulttype = att->atttypid;
            fselect->resulttypmod = att->atttypmod;
            /* save attribute's collation for parse_collate.c */
            fselect->resultcollid = att->attcollation;
            return (Node *) fselect;
        }
    }
 
    return NULL;                /* funcname does not match any column */
}

References FieldSelect::arg, expandRecordVariable(), FieldSelect::fieldnum, funcname, get_expr_result_tupdesc(), GetNSItemByRangeTablePosn(), i, InvalidAttrNumber, IsA, makeNode, NameStr, TupleDescData::natts, scanNSItemForColumn(), and TupleDescAttr.

Referenced by ParseFuncOrColumn().

ParseFuncOrColumn()

Node* ParseFuncOrColumn	(	ParseState *	pstate,
		List *	funcname,
		List *	fargs,
		Node *	last_srf,
		FuncCall *	fn,
		bool	proc_call,
		int	location
	)

Definition at line 90 of file parse_func.c.

{
    bool        is_column = (fn == NULL);
    List       *agg_order = (fn ? fn->agg_order : NIL);
    Expr       *agg_filter = NULL;
    WindowDef  *over = (fn ? fn->over : NULL);
    bool        agg_within_group = (fn ? fn->agg_within_group : false);
    bool        agg_star = (fn ? fn->agg_star : false);
    bool        agg_distinct = (fn ? fn->agg_distinct : false);
    bool        func_variadic = (fn ? fn->func_variadic : false);
    CoercionForm funcformat = (fn ? fn->funcformat : COERCE_EXPLICIT_CALL);
    bool        could_be_projection;
    Oid         rettype;
    Oid         funcid;
    ListCell   *l;
    Node       *first_arg = NULL;
    int         nargs;
    int         nargsplusdefs;
    Oid         actual_arg_types[FUNC_MAX_ARGS];
    Oid        *declared_arg_types;
    List       *argnames;
    List       *argdefaults;
    Node       *retval;
    bool        retset;
    int         nvargs;
    Oid         vatype;
    FuncDetailCode fdresult;
    char        aggkind = 0;
    ParseCallbackState pcbstate;
 
    /*
     * If there's an aggregate filter, transform it using transformWhereClause
     */
    if (fn && fn->agg_filter != NULL)
        agg_filter = (Expr *) transformWhereClause(pstate, fn->agg_filter,
                                                   EXPR_KIND_FILTER,
                                                   "FILTER");
 
    /*
     * Most of the rest of the parser just assumes that functions do not have
     * more than FUNC_MAX_ARGS parameters.  We have to test here to protect
     * against array overruns, etc.  Of course, this may not be a function,
     * but the test doesn't hurt.
     */
    if (list_length(fargs) > FUNC_MAX_ARGS)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                 errmsg_plural("cannot pass more than %d argument to a function",
                               "cannot pass more than %d arguments to a function",
                               FUNC_MAX_ARGS,
                               FUNC_MAX_ARGS),
                 parser_errposition(pstate, location)));
 
    /*
     * Extract arg type info in preparation for function lookup.
     *
     * If any arguments are Param markers of type VOID, we discard them from
     * the parameter list. This is a hack to allow the JDBC driver to not have
     * to distinguish "input" and "output" parameter symbols while parsing
     * function-call constructs.  Don't do this if dealing with column syntax,
     * nor if we had WITHIN GROUP (because in that case it's critical to keep
     * the argument count unchanged).
     */
    nargs = 0;
    foreach(l, fargs)
    {
        Node       *arg = lfirst(l);
        Oid         argtype = exprType(arg);
 
        if (argtype == VOIDOID && IsA(arg, Param) &&
            !is_column && !agg_within_group)
        {
            fargs = foreach_delete_current(fargs, l);
            continue;
        }
 
        actual_arg_types[nargs++] = argtype;
    }
 
    /*
     * Check for named arguments; if there are any, build a list of names.
     *
     * We allow mixed notation (some named and some not), but only with all
     * the named parameters after all the unnamed ones.  So the name list
     * corresponds to the last N actual parameters and we don't need any extra
     * bookkeeping to match things up.
     */
    argnames = NIL;
    foreach(l, fargs)
    {
        Node       *arg = lfirst(l);
 
        if (IsA(arg, NamedArgExpr))
        {
            NamedArgExpr *na = (NamedArgExpr *) arg;
            ListCell   *lc;
 
            /* Reject duplicate arg names */
            foreach(lc, argnames)
            {
                if (strcmp(na->name, (char *) lfirst(lc)) == 0)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("argument name \"%s\" used more than once",
                                    na->name),
                             parser_errposition(pstate, na->location)));
            }
            argnames = lappend(argnames, na->name);
        }
        else
        {
            if (argnames != NIL)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("positional argument cannot follow named argument"),
                         parser_errposition(pstate, exprLocation(arg))));
        }
    }
 
    if (fargs)
    {
        first_arg = linitial(fargs);
        Assert(first_arg != NULL);
    }
 
    /*
     * Decide whether it's legitimate to consider the construct to be a column
     * projection.  For that, there has to be a single argument of complex
     * type, the function name must not be qualified, and there cannot be any
     * syntactic decoration that'd require it to be a function (such as
     * aggregate or variadic decoration, or named arguments).
     */
    could_be_projection = (nargs == 1 && !proc_call &&
                           agg_order == NIL && agg_filter == NULL &&
                           !agg_star && !agg_distinct && over == NULL &&
                           !func_variadic && argnames == NIL &&
                           list_length(funcname) == 1 &&
                           (actual_arg_types[0] == RECORDOID ||
                            ISCOMPLEX(actual_arg_types[0])));
 
    /*
     * If it's column syntax, check for column projection case first.
     */
    if (could_be_projection && is_column)
    {
        retval = ParseComplexProjection(pstate,
                                        strVal(linitial(funcname)),
                                        first_arg,
                                        location);
        if (retval)
            return retval;
 
        /*
         * If ParseComplexProjection doesn't recognize it as a projection,
         * just press on.
         */
    }
 
    /*
     * func_get_detail looks up the function in the catalogs, does
     * disambiguation for polymorphic functions, handles inheritance, and
     * returns the funcid and type and set or singleton status of the
     * function's return value.  It also returns the true argument types to
     * the function.
     *
     * Note: for a named-notation or variadic function call, the reported
     * "true" types aren't really what is in pg_proc: the types are reordered
     * to match the given argument order of named arguments, and a variadic
     * argument is replaced by a suitable number of copies of its element
     * type.  We'll fix up the variadic case below.  We may also have to deal
     * with default arguments.
     */
 
    setup_parser_errposition_callback(&pcbstate, pstate, location);
 
    fdresult = func_get_detail(funcname, fargs, argnames, nargs,
                               actual_arg_types,
                               !func_variadic, true, proc_call,
                               &funcid, &rettype, &retset,
                               &nvargs, &vatype,
                               &declared_arg_types, &argdefaults);
 
    cancel_parser_errposition_callback(&pcbstate);
 
    /*
     * Check for various wrong-kind-of-routine cases.
     */
 
    /* If this is a CALL, reject things that aren't procedures */
    if (proc_call &&
        (fdresult == FUNCDETAIL_NORMAL ||
         fdresult == FUNCDETAIL_AGGREGATE ||
         fdresult == FUNCDETAIL_WINDOWFUNC ||
         fdresult == FUNCDETAIL_COERCION))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("%s is not a procedure",
                        func_signature_string(funcname, nargs,
                                              argnames,
                                              actual_arg_types)),
                 errhint("To call a function, use SELECT."),
                 parser_errposition(pstate, location)));
    /* Conversely, if not a CALL, reject procedures */
    if (fdresult == FUNCDETAIL_PROCEDURE && !proc_call)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("%s is a procedure",
                        func_signature_string(funcname, nargs,
                                              argnames,
                                              actual_arg_types)),
                 errhint("To call a procedure, use CALL."),
                 parser_errposition(pstate, location)));
 
    if (fdresult == FUNCDETAIL_NORMAL ||
        fdresult == FUNCDETAIL_PROCEDURE ||
        fdresult == FUNCDETAIL_COERCION)
    {
        /*
         * In these cases, complain if there was anything indicating it must
         * be an aggregate or window function.
         */
        if (agg_star)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("%s(*) specified, but %s is not an aggregate function",
                            NameListToString(funcname),
                            NameListToString(funcname)),
                     parser_errposition(pstate, location)));
        if (agg_distinct)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("DISTINCT specified, but %s is not an aggregate function",
                            NameListToString(funcname)),
                     parser_errposition(pstate, location)));
        if (agg_within_group)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("WITHIN GROUP specified, but %s is not an aggregate function",
                            NameListToString(funcname)),
                     parser_errposition(pstate, location)));
        if (agg_order != NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("ORDER BY specified, but %s is not an aggregate function",
                            NameListToString(funcname)),
                     parser_errposition(pstate, location)));
        if (agg_filter)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("FILTER specified, but %s is not an aggregate function",
                            NameListToString(funcname)),
                     parser_errposition(pstate, location)));
        if (over)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("OVER specified, but %s is not a window function nor an aggregate function",
                            NameListToString(funcname)),
                     parser_errposition(pstate, location)));
    }
 
    /*
     * So far so good, so do some fdresult-type-specific processing.
     */
    if (fdresult == FUNCDETAIL_NORMAL || fdresult == FUNCDETAIL_PROCEDURE)
    {
        /* Nothing special to do for these cases. */
    }
    else if (fdresult == FUNCDETAIL_AGGREGATE)
    {
        /*
         * It's an aggregate; fetch needed info from the pg_aggregate entry.
         */
        HeapTuple   tup;
        Form_pg_aggregate classForm;
        int         catDirectArgs;
 
        tup = SearchSysCache1(AGGFNOID, ObjectIdGetDatum(funcid));
        if (!HeapTupleIsValid(tup)) /* should not happen */
            elog(ERROR, "cache lookup failed for aggregate %u", funcid);
        classForm = (Form_pg_aggregate) GETSTRUCT(tup);
        aggkind = classForm->aggkind;
        catDirectArgs = classForm->aggnumdirectargs;
        ReleaseSysCache(tup);
 
        /* Now check various disallowed cases. */
        if (AGGKIND_IS_ORDERED_SET(aggkind))
        {
            int         numAggregatedArgs;
            int         numDirectArgs;
 
            if (!agg_within_group)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("WITHIN GROUP is required for ordered-set aggregate %s",
                                NameListToString(funcname)),
                         parser_errposition(pstate, location)));
            if (over)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("OVER is not supported for ordered-set aggregate %s",
                                NameListToString(funcname)),
                         parser_errposition(pstate, location)));
            /* gram.y rejects DISTINCT + WITHIN GROUP */
            Assert(!agg_distinct);
            /* gram.y rejects VARIADIC + WITHIN GROUP */
            Assert(!func_variadic);
 
            /*
             * Since func_get_detail was working with an undifferentiated list
             * of arguments, it might have selected an aggregate that doesn't
             * really match because it requires a different division of direct
             * and aggregated arguments.  Check that the number of direct
             * arguments is actually OK; if not, throw an "undefined function"
             * error, similarly to the case where a misplaced ORDER BY is used
             * in a regular aggregate call.
             */
            numAggregatedArgs = list_length(agg_order);
            numDirectArgs = nargs - numAggregatedArgs;
            Assert(numDirectArgs >= 0);
 
            if (!OidIsValid(vatype))
            {
                /* Test is simple if aggregate isn't variadic */
                if (numDirectArgs != catDirectArgs)
                    ereport(ERROR,
                            (errcode(ERRCODE_UNDEFINED_FUNCTION),
                             errmsg("function %s does not exist",
                                    func_signature_string(funcname, nargs,
                                                          argnames,
                                                          actual_arg_types)),
                             errhint_plural("There is an ordered-set aggregate %s, but it requires %d direct argument, not %d.",
                                            "There is an ordered-set aggregate %s, but it requires %d direct arguments, not %d.",
                                            catDirectArgs,
                                            NameListToString(funcname),
                                            catDirectArgs, numDirectArgs),
                             parser_errposition(pstate, location)));
            }
            else
            {
                /*
                 * If it's variadic, we have two cases depending on whether
                 * the agg was "... ORDER BY VARIADIC" or "..., VARIADIC ORDER
                 * BY VARIADIC".  It's the latter if catDirectArgs equals
                 * pronargs; to save a catalog lookup, we reverse-engineer
                 * pronargs from the info we got from func_get_detail.
                 */
                int         pronargs;
 
                pronargs = nargs;
                if (nvargs > 1)
                    pronargs -= nvargs - 1;
                if (catDirectArgs < pronargs)
                {
                    /* VARIADIC isn't part of direct args, so still easy */
                    if (numDirectArgs != catDirectArgs)
                        ereport(ERROR,
                                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                                 errmsg("function %s does not exist",
                                        func_signature_string(funcname, nargs,
                                                              argnames,
                                                              actual_arg_types)),
                                 errhint_plural("There is an ordered-set aggregate %s, but it requires %d direct argument, not %d.",
                                                "There is an ordered-set aggregate %s, but it requires %d direct arguments, not %d.",
                                                catDirectArgs,
                                                NameListToString(funcname),
                                                catDirectArgs, numDirectArgs),
                                 parser_errposition(pstate, location)));
                }
                else
                {
                    /*
                     * Both direct and aggregated args were declared variadic.
                     * For a standard ordered-set aggregate, it's okay as long
                     * as there aren't too few direct args.  For a
                     * hypothetical-set aggregate, we assume that the
                     * hypothetical arguments are those that matched the
                     * variadic parameter; there must be just as many of them
                     * as there are aggregated arguments.
                     */
                    if (aggkind == AGGKIND_HYPOTHETICAL)
                    {
                        if (nvargs != 2 * numAggregatedArgs)
                            ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                                     errmsg("function %s does not exist",
                                            func_signature_string(funcname, nargs,
                                                                  argnames,
                                                                  actual_arg_types)),
                                     errhint("To use the hypothetical-set aggregate %s, the number of hypothetical direct arguments (here %d) must match the number of ordering columns (here %d).",
                                             NameListToString(funcname),
                                             nvargs - numAggregatedArgs, numAggregatedArgs),
                                     parser_errposition(pstate, location)));
                    }
                    else
                    {
                        if (nvargs <= numAggregatedArgs)
                            ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                                     errmsg("function %s does not exist",
                                            func_signature_string(funcname, nargs,
                                                                  argnames,
                                                                  actual_arg_types)),
                                     errhint_plural("There is an ordered-set aggregate %s, but it requires at least %d direct argument.",
                                                    "There is an ordered-set aggregate %s, but it requires at least %d direct arguments.",
                                                    catDirectArgs,
                                                    NameListToString(funcname),
                                                    catDirectArgs),
                                     parser_errposition(pstate, location)));
                    }
                }
            }
 
            /* Check type matching of hypothetical arguments */
            if (aggkind == AGGKIND_HYPOTHETICAL)
                unify_hypothetical_args(pstate, fargs, numAggregatedArgs,
                                        actual_arg_types, declared_arg_types);
        }
        else
        {
            /* Normal aggregate, so it can't have WITHIN GROUP */
            if (agg_within_group)
                ereport(ERROR,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("%s is not an ordered-set aggregate, so it cannot have WITHIN GROUP",
                                NameListToString(funcname)),
                         parser_errposition(pstate, location)));
        }
    }
    else if (fdresult == FUNCDETAIL_WINDOWFUNC)
    {
        /*
         * True window functions must be called with a window definition.
         */
        if (!over)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("window function %s requires an OVER clause",
                            NameListToString(funcname)),
                     parser_errposition(pstate, location)));
        /* And, per spec, WITHIN GROUP isn't allowed */
        if (agg_within_group)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("window function %s cannot have WITHIN GROUP",
                            NameListToString(funcname)),
                     parser_errposition(pstate, location)));
    }
    else if (fdresult == FUNCDETAIL_COERCION)
    {
        /*
         * We interpreted it as a type coercion. coerce_type can handle these
         * cases, so why duplicate code...
         */
        return coerce_type(pstate, linitial(fargs),
                           actual_arg_types[0], rettype, -1,
                           COERCION_EXPLICIT, COERCE_EXPLICIT_CALL, location);
    }
    else if (fdresult == FUNCDETAIL_MULTIPLE)
    {
        /*
         * We found multiple possible functional matches.  If we are dealing
         * with attribute notation, return failure, letting the caller report
         * "no such column" (we already determined there wasn't one).  If
         * dealing with function notation, report "ambiguous function",
         * regardless of whether there's also a column by this name.
         */
        if (is_column)
            return NULL;
 
        if (proc_call)
            ereport(ERROR,
                    (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                     errmsg("procedure %s is not unique",
                            func_signature_string(funcname, nargs, argnames,
                                                  actual_arg_types)),
                     errhint("Could not choose a best candidate procedure. "
                             "You might need to add explicit type casts."),
                     parser_errposition(pstate, location)));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
                     errmsg("function %s is not unique",
                            func_signature_string(funcname, nargs, argnames,
                                                  actual_arg_types)),
                     errhint("Could not choose a best candidate function. "
                             "You might need to add explicit type casts."),
                     parser_errposition(pstate, location)));
    }
    else
    {
        /*
         * Not found as a function.  If we are dealing with attribute
         * notation, return failure, letting the caller report "no such
         * column" (we already determined there wasn't one).
         */
        if (is_column)
            return NULL;
 
        /*
         * Check for column projection interpretation, since we didn't before.
         */
        if (could_be_projection)
        {
            retval = ParseComplexProjection(pstate,
                                            strVal(linitial(funcname)),
                                            first_arg,
                                            location);
            if (retval)
                return retval;
        }
 
        /*
         * No function, and no column either.  Since we're dealing with
         * function notation, report "function does not exist".
         */
        if (list_length(agg_order) > 1 && !agg_within_group)
        {
            /* It's agg(x, ORDER BY y,z) ... perhaps misplaced ORDER BY */
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("function %s does not exist",
                            func_signature_string(funcname, nargs, argnames,
                                                  actual_arg_types)),
                     errhint("No aggregate function matches the given name and argument types. "
                             "Perhaps you misplaced ORDER BY; ORDER BY must appear "
                             "after all regular arguments of the aggregate."),
                     parser_errposition(pstate, location)));
        }
        else if (proc_call)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("procedure %s does not exist",
                            func_signature_string(funcname, nargs, argnames,
                                                  actual_arg_types)),
                     errhint("No procedure matches the given name and argument types. "
                             "You might need to add explicit type casts."),
                     parser_errposition(pstate, location)));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("function %s does not exist",
                            func_signature_string(funcname, nargs, argnames,
                                                  actual_arg_types)),
                     errhint("No function matches the given name and argument types. "
                             "You might need to add explicit type casts."),
                     parser_errposition(pstate, location)));
    }
 
    /*
     * If there are default arguments, we have to include their types in
     * actual_arg_types for the purpose of checking generic type consistency.
     * However, we do NOT put them into the generated parse node, because
     * their actual values might change before the query gets run.  The
     * planner has to insert the up-to-date values at plan time.
     */
    nargsplusdefs = nargs;
    foreach(l, argdefaults)
    {
        Node       *expr = (Node *) lfirst(l);
 
        /* probably shouldn't happen ... */
        if (nargsplusdefs >= FUNC_MAX_ARGS)
            ereport(ERROR,
                    (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                     errmsg_plural("cannot pass more than %d argument to a function",
                                   "cannot pass more than %d arguments to a function",
                                   FUNC_MAX_ARGS,
                                   FUNC_MAX_ARGS),
                     parser_errposition(pstate, location)));
 
        actual_arg_types[nargsplusdefs++] = exprType(expr);
    }
 
    /*
     * enforce consistency with polymorphic argument and return types,
     * possibly adjusting return type or declared_arg_types (which will be
     * used as the cast destination by make_fn_arguments)
     */
    rettype = enforce_generic_type_consistency(actual_arg_types,
                                               declared_arg_types,
                                               nargsplusdefs,
                                               rettype,
                                               false);
 
    /* perform the necessary typecasting of arguments */
    make_fn_arguments(pstate, fargs, actual_arg_types, declared_arg_types);
 
    /*
     * If the function isn't actually variadic, forget any VARIADIC decoration
     * on the call.  (Perhaps we should throw an error instead, but
     * historically we've allowed people to write that.)
     */
    if (!OidIsValid(vatype))
    {
        Assert(nvargs == 0);
        func_variadic = false;
    }
 
    /*
     * If it's a variadic function call, transform the last nvargs arguments
     * into an array --- unless it's an "any" variadic.
     */
    if (nvargs > 0 && vatype != ANYOID)
    {
        ArrayExpr  *newa = makeNode(ArrayExpr);
        int         non_var_args = nargs - nvargs;
        List       *vargs;
 
        Assert(non_var_args >= 0);
        vargs = list_copy_tail(fargs, non_var_args);
        fargs = list_truncate(fargs, non_var_args);
 
        newa->elements = vargs;
        /* assume all the variadic arguments were coerced to the same type */
        newa->element_typeid = exprType((Node *) linitial(vargs));
        newa->array_typeid = get_array_type(newa->element_typeid);
        if (!OidIsValid(newa->array_typeid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("could not find array type for data type %s",
                            format_type_be(newa->element_typeid)),
                     parser_errposition(pstate, exprLocation((Node *) vargs))));
        /* array_collid will be set by parse_collate.c */
        newa->multidims = false;
        newa->location = exprLocation((Node *) vargs);
 
        fargs = lappend(fargs, newa);
 
        /* We could not have had VARIADIC marking before ... */
        Assert(!func_variadic);
        /* ... but now, it's a VARIADIC call */
        func_variadic = true;
    }
 
    /*
     * If an "any" variadic is called with explicit VARIADIC marking, insist
     * that the variadic parameter be of some array type.
     */
    if (nargs > 0 && vatype == ANYOID && func_variadic)
    {
        Oid         va_arr_typid = actual_arg_types[nargs - 1];
 
        if (!OidIsValid(get_base_element_type(va_arr_typid)))
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("VARIADIC argument must be an array"),
                     parser_errposition(pstate,
                                        exprLocation((Node *) llast(fargs)))));
    }
 
    /* if it returns a set, check that's OK */
    if (retset)
        check_srf_call_placement(pstate, last_srf, location);
 
    /* build the appropriate output structure */
    if (fdresult == FUNCDETAIL_NORMAL || fdresult == FUNCDETAIL_PROCEDURE)
    {
        FuncExpr   *funcexpr = makeNode(FuncExpr);
 
        funcexpr->funcid = funcid;
        funcexpr->funcresulttype = rettype;
        funcexpr->funcretset = retset;
        funcexpr->funcvariadic = func_variadic;
        funcexpr->funcformat = funcformat;
        /* funccollid and inputcollid will be set by parse_collate.c */
        funcexpr->args = fargs;
        funcexpr->location = location;
 
        retval = (Node *) funcexpr;
    }
    else if (fdresult == FUNCDETAIL_AGGREGATE && !over)
    {
        /* aggregate function */
        Aggref     *aggref = makeNode(Aggref);
 
        aggref->aggfnoid = funcid;
        aggref->aggtype = rettype;
        /* aggcollid and inputcollid will be set by parse_collate.c */
        aggref->aggtranstype = InvalidOid;  /* will be set by planner */
        /* aggargtypes will be set by transformAggregateCall */
        /* aggdirectargs and args will be set by transformAggregateCall */
        /* aggorder and aggdistinct will be set by transformAggregateCall */
        aggref->aggfilter = agg_filter;
        aggref->aggstar = agg_star;
        aggref->aggvariadic = func_variadic;
        aggref->aggkind = aggkind;
        aggref->aggpresorted = false;
        /* agglevelsup will be set by transformAggregateCall */
        aggref->aggsplit = AGGSPLIT_SIMPLE; /* planner might change this */
        aggref->aggno = -1;     /* planner will set aggno and aggtransno */
        aggref->aggtransno = -1;
        aggref->location = location;
 
        /*
         * Reject attempt to call a parameterless aggregate without (*)
         * syntax.  This is mere pedantry but some folks insisted ...
         */
        if (fargs == NIL && !agg_star && !agg_within_group)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("%s(*) must be used to call a parameterless aggregate function",
                            NameListToString(funcname)),
                     parser_errposition(pstate, location)));
 
        if (retset)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("aggregates cannot return sets"),
                     parser_errposition(pstate, location)));
 
        /*
         * We might want to support named arguments later, but disallow it for
         * now.  We'd need to figure out the parsed representation (should the
         * NamedArgExprs go above or below the TargetEntry nodes?) and then
         * teach the planner to reorder the list properly.  Or maybe we could
         * make transformAggregateCall do that?  However, if you'd also like
         * to allow default arguments for aggregates, we'd need to do it in
         * planning to avoid semantic problems.
         */
        if (argnames != NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("aggregates cannot use named arguments"),
                     parser_errposition(pstate, location)));
 
        /* parse_agg.c does additional aggregate-specific processing */
        transformAggregateCall(pstate, aggref, fargs, agg_order, agg_distinct);
 
        retval = (Node *) aggref;
    }
    else
    {
        /* window function */
        WindowFunc *wfunc = makeNode(WindowFunc);
 
        Assert(over);           /* lack of this was checked above */
        Assert(!agg_within_group);  /* also checked above */
 
        wfunc->winfnoid = funcid;
        wfunc->wintype = rettype;
        /* wincollid and inputcollid will be set by parse_collate.c */
        wfunc->args = fargs;
        /* winref will be set by transformWindowFuncCall */
        wfunc->winstar = agg_star;
        wfunc->winagg = (fdresult == FUNCDETAIL_AGGREGATE);
        wfunc->aggfilter = agg_filter;
        wfunc->runCondition = NIL;
        wfunc->location = location;
 
        /*
         * agg_star is allowed for aggregate functions but distinct isn't
         */
        if (agg_distinct)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("DISTINCT is not implemented for window functions"),
                     parser_errposition(pstate, location)));
 
        /*
         * Reject attempt to call a parameterless aggregate without (*)
         * syntax.  This is mere pedantry but some folks insisted ...
         */
        if (wfunc->winagg && fargs == NIL && !agg_star)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("%s(*) must be used to call a parameterless aggregate function",
                            NameListToString(funcname)),
                     parser_errposition(pstate, location)));
 
        /*
         * ordered aggs not allowed in windows yet
         */
        if (agg_order != NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("aggregate ORDER BY is not implemented for window functions"),
                     parser_errposition(pstate, location)));
 
        /*
         * FILTER is not yet supported with true window functions
         */
        if (!wfunc->winagg && agg_filter)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("FILTER is not implemented for non-aggregate window functions"),
                     parser_errposition(pstate, location)));
 
        /*
         * Window functions can't either take or return sets
         */
        if (pstate->p_last_srf != last_srf)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("window function calls cannot contain set-returning function calls"),
                     errhint("You might be able to move the set-returning function into a LATERAL FROM item."),
                     parser_errposition(pstate,
                                        exprLocation(pstate->p_last_srf))));
 
        if (retset)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("window functions cannot return sets"),
                     parser_errposition(pstate, location)));
 
        /* parse_agg.c does additional window-func-specific processing */
        transformWindowFuncCall(pstate, wfunc, over);
 
        retval = (Node *) wfunc;
    }
 
    /* if it returns a set, remember it for error checks at higher levels */
    if (retset)
        pstate->p_last_srf = retval;
 
    return retval;
}

References Aggref::aggfilter, WindowFunc::aggfilter, Aggref::aggfnoid, AGGSPLIT_SIMPLE, arg, WindowFunc::args, FuncExpr::args, Assert, cancel_parser_errposition_callback(), check_srf_call_placement(), COERCE_EXPLICIT_CALL, coerce_type(), COERCION_EXPLICIT, ArrayExpr::elements, elog, enforce_generic_type_consistency(), ereport, errcode(), errhint(), errhint_plural(), errmsg(), errmsg_plural(), ERROR, EXPR_KIND_FILTER, exprLocation(), exprType(), fn(), foreach_delete_current, format_type_be(), func_get_detail(), FUNC_MAX_ARGS, func_signature_string(), FUNCDETAIL_AGGREGATE, FUNCDETAIL_COERCION, FUNCDETAIL_MULTIPLE, FUNCDETAIL_NORMAL, FUNCDETAIL_PROCEDURE, FUNCDETAIL_WINDOWFUNC, FuncExpr::funcid, funcname, get_array_type(), get_base_element_type(), GETSTRUCT, HeapTupleIsValid, InvalidOid, IsA, ISCOMPLEX, lappend(), lfirst, linitial, list_copy_tail(), list_length(), list_truncate(), llast, Aggref::location, WindowFunc::location, FuncExpr::location, NamedArgExpr::location, ArrayExpr::location, make_fn_arguments(), makeNode, NameListToString(), NIL, ObjectIdGetDatum(), OidIsValid, ParseState::p_last_srf, ParseComplexProjection(), parser_errposition(), pronargs, ReleaseSysCache(), SearchSysCache1(), setup_parser_errposition_callback(), strVal, transformAggregateCall(), transformWhereClause(), transformWindowFuncCall(), unify_hypothetical_args(), and WindowFunc::winfnoid.

Referenced by sql_fn_post_column_ref(), transformCallStmt(), transformColumnRef(), transformFuncCall(), and transformIndirection().

unify_hypothetical_args()

static void unify_hypothetical_args ( ParseState *  pstate, List *  fargs, int  numAggregatedArgs, Oid *  actual_arg_types, Oid *  declared_arg_types  )

static

Definition at line 1741 of file parse_func.c.

{
    int         numDirectArgs,
                numNonHypotheticalArgs;
    int         hargpos;
 
    numDirectArgs = list_length(fargs) - numAggregatedArgs;
    numNonHypotheticalArgs = numDirectArgs - numAggregatedArgs;
    /* safety check (should only trigger with a misdeclared agg) */
    if (numNonHypotheticalArgs < 0)
        elog(ERROR, "incorrect number of arguments to hypothetical-set aggregate");
 
    /* Check each hypothetical arg and corresponding aggregated arg */
    for (hargpos = numNonHypotheticalArgs; hargpos < numDirectArgs; hargpos++)
    {
        int         aargpos = numDirectArgs + (hargpos - numNonHypotheticalArgs);
        ListCell   *harg = list_nth_cell(fargs, hargpos);
        ListCell   *aarg = list_nth_cell(fargs, aargpos);
        Oid         commontype;
        int32       commontypmod;
 
        /* A mismatch means AggregateCreate didn't check properly ... */
        if (declared_arg_types[hargpos] != declared_arg_types[aargpos])
            elog(ERROR, "hypothetical-set aggregate has inconsistent declared argument types");
 
        /* No need to unify if make_fn_arguments will coerce */
        if (declared_arg_types[hargpos] != ANYOID)
            continue;
 
        /*
         * Select common type, giving preference to the aggregated argument's
         * type (we'd rather coerce the direct argument once than coerce all
         * the aggregated values).
         */
        commontype = select_common_type(pstate,
                                        list_make2(lfirst(aarg), lfirst(harg)),
                                        "WITHIN GROUP",
                                        NULL);
        commontypmod = select_common_typmod(pstate,
                                            list_make2(lfirst(aarg), lfirst(harg)),
                                            commontype);
 
        /*
         * Perform the coercions.  We don't need to worry about NamedArgExprs
         * here because they aren't supported with aggregates.
         */
        lfirst(harg) = coerce_type(pstate,
                                   (Node *) lfirst(harg),
                                   actual_arg_types[hargpos],
                                   commontype, commontypmod,
                                   COERCION_IMPLICIT,
                                   COERCE_IMPLICIT_CAST,
                                   -1);
        actual_arg_types[hargpos] = commontype;
        lfirst(aarg) = coerce_type(pstate,
                                   (Node *) lfirst(aarg),
                                   actual_arg_types[aargpos],
                                   commontype, commontypmod,
                                   COERCION_IMPLICIT,
                                   COERCE_IMPLICIT_CAST,
                                   -1);
        actual_arg_types[aargpos] = commontype;
    }
}

References COERCE_IMPLICIT_CAST, coerce_type(), COERCION_IMPLICIT, elog, ERROR, lfirst, list_length(), list_make2, list_nth_cell(), select_common_type(), and select_common_typmod().

Referenced by ParseFuncOrColumn().