functioncmds.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_aggregate.h"
#include "catalog/pg_cast.h"
#include "catalog/pg_language.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_transform.h"
#include "catalog/pg_type.h"
#include "commands/defrem.h"
#include "commands/extension.h"
#include "commands/proclang.h"
#include "executor/executor.h"
#include "executor/functions.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/optimizer.h"
#include "parser/analyze.h"
#include "parser/parse_coerce.h"
#include "parser/parse_collate.h"
#include "parser/parse_expr.h"
#include "parser/parse_func.h"
#include "parser/parse_type.h"
#include "pgstat.h"
#include "tcop/pquery.h"
#include "tcop/utility.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

Include dependency graph for functioncmds.c:

Go to the source code of this file.

Functions
static void	compute_return_type (TypeName *returnType, Oid languageOid, Oid *prorettype_p, bool *returnsSet_p)
void	interpret_function_parameter_list (ParseState *pstate, List *parameters, Oid languageOid, ObjectType objtype, oidvector **parameterTypes, List **parameterTypes_list, ArrayType **allParameterTypes, ArrayType **parameterModes, ArrayType **parameterNames, List **inParameterNames_list, List **parameterDefaults, Oid *variadicArgType, Oid *requiredResultType)
static bool	compute_common_attribute (ParseState *pstate, bool is_procedure, DefElem *defel, DefElem **volatility_item, DefElem **strict_item, DefElem **security_item, DefElem **leakproof_item, List **set_items, DefElem **cost_item, DefElem **rows_item, DefElem **support_item, DefElem **parallel_item)
static char	interpret_func_volatility (DefElem *defel)
static char	interpret_func_parallel (DefElem *defel)
static ArrayType *	update_proconfig_value (ArrayType *a, List *set_items)
static Oid	interpret_func_support (DefElem *defel)
static void	compute_function_attributes (ParseState *pstate, bool is_procedure, List *options, List **as, char **language, Node **transform, bool *windowfunc_p, char *volatility_p, bool *strict_p, bool *security_definer, bool *leakproof_p, ArrayType **proconfig, float4 *procost, float4 *prorows, Oid *prosupport, char *parallel_p)
static void	interpret_AS_clause (Oid languageOid, const char *languageName, char *funcname, List *as, Node *sql_body_in, List *parameterTypes, List *inParameterNames, char **prosrc_str_p, char **probin_str_p, Node **sql_body_out, const char *queryString)
ObjectAddress	CreateFunction (ParseState *pstate, CreateFunctionStmt *stmt)
void	RemoveFunctionById (Oid funcOid)
ObjectAddress	AlterFunction (ParseState *pstate, AlterFunctionStmt *stmt)
ObjectAddress	CreateCast (CreateCastStmt *stmt)
static void	check_transform_function (Form_pg_proc procstruct)
ObjectAddress	CreateTransform (CreateTransformStmt *stmt)
Oid	get_transform_oid (Oid type_id, Oid lang_id, bool missing_ok)
void	IsThereFunctionInNamespace (const char *proname, int pronargs, oidvector *proargtypes, Oid nspOid)
void	ExecuteDoStmt (ParseState *pstate, DoStmt *stmt, bool atomic)
void	ExecuteCallStmt (CallStmt *stmt, ParamListInfo params, bool atomic, DestReceiver *dest)
TupleDesc	CallStmtResultDesc (CallStmt *stmt)

Function Documentation

AlterFunction()

ObjectAddress AlterFunction	(	ParseState *	pstate,
		AlterFunctionStmt *	stmt
	)

Definition at line 1358 of file functioncmds.c.

{
    HeapTuple   tup;
    Oid         funcOid;
    Form_pg_proc procForm;
    bool        is_procedure;
    Relation    rel;
    ListCell   *l;
    DefElem    *volatility_item = NULL;
    DefElem    *strict_item = NULL;
    DefElem    *security_def_item = NULL;
    DefElem    *leakproof_item = NULL;
    List       *set_items = NIL;
    DefElem    *cost_item = NULL;
    DefElem    *rows_item = NULL;
    DefElem    *support_item = NULL;
    DefElem    *parallel_item = NULL;
    ObjectAddress address;
 
    rel = table_open(ProcedureRelationId, RowExclusiveLock);
 
    funcOid = LookupFuncWithArgs(stmt->objtype, stmt->func, false);
 
    ObjectAddressSet(address, ProcedureRelationId, funcOid);
 
    tup = SearchSysCacheCopy1(PROCOID, ObjectIdGetDatum(funcOid));
    if (!HeapTupleIsValid(tup)) /* should not happen */
        elog(ERROR, "cache lookup failed for function %u", funcOid);
 
    procForm = (Form_pg_proc) GETSTRUCT(tup);
 
    /* Permission check: must own function */
    if (!object_ownercheck(ProcedureRelationId, funcOid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, stmt->objtype,
                       NameListToString(stmt->func->objname));
 
    if (procForm->prokind == PROKIND_AGGREGATE)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("\"%s\" is an aggregate function",
                        NameListToString(stmt->func->objname))));
 
    is_procedure = (procForm->prokind == PROKIND_PROCEDURE);
 
    /* Examine requested actions. */
    foreach(l, stmt->actions)
    {
        DefElem    *defel = (DefElem *) lfirst(l);
 
        if (compute_common_attribute(pstate,
                                     is_procedure,
                                     defel,
                                     &volatility_item,
                                     &strict_item,
                                     &security_def_item,
                                     &leakproof_item,
                                     &set_items,
                                     &cost_item,
                                     &rows_item,
                                     &support_item,
                                     &parallel_item) == false)
            elog(ERROR, "option \"%s\" not recognized", defel->defname);
    }
 
    if (volatility_item)
        procForm->provolatile = interpret_func_volatility(volatility_item);
    if (strict_item)
        procForm->proisstrict = boolVal(strict_item->arg);
    if (security_def_item)
        procForm->prosecdef = boolVal(security_def_item->arg);
    if (leakproof_item)
    {
        procForm->proleakproof = boolVal(leakproof_item->arg);
        if (procForm->proleakproof && !superuser())
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("only superuser can define a leakproof function")));
    }
    if (cost_item)
    {
        procForm->procost = defGetNumeric(cost_item);
        if (procForm->procost <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("COST must be positive")));
    }
    if (rows_item)
    {
        procForm->prorows = defGetNumeric(rows_item);
        if (procForm->prorows <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("ROWS must be positive")));
        if (!procForm->proretset)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("ROWS is not applicable when function does not return a set")));
    }
    if (support_item)
    {
        /* interpret_func_support handles the privilege check */
        Oid         newsupport = interpret_func_support(support_item);
 
        /* Add or replace dependency on support function */
        if (OidIsValid(procForm->prosupport))
        {
            if (changeDependencyFor(ProcedureRelationId, funcOid,
                                    ProcedureRelationId, procForm->prosupport,
                                    newsupport) != 1)
                elog(ERROR, "could not change support dependency for function %s",
                     get_func_name(funcOid));
        }
        else
        {
            ObjectAddress referenced;
 
            referenced.classId = ProcedureRelationId;
            referenced.objectId = newsupport;
            referenced.objectSubId = 0;
            recordDependencyOn(&address, &referenced, DEPENDENCY_NORMAL);
        }
 
        procForm->prosupport = newsupport;
    }
    if (parallel_item)
        procForm->proparallel = interpret_func_parallel(parallel_item);
    if (set_items)
    {
        Datum       datum;
        bool        isnull;
        ArrayType  *a;
        Datum       repl_val[Natts_pg_proc];
        bool        repl_null[Natts_pg_proc];
        bool        repl_repl[Natts_pg_proc];
 
        /* extract existing proconfig setting */
        datum = SysCacheGetAttr(PROCOID, tup, Anum_pg_proc_proconfig, &isnull);
        a = isnull ? NULL : DatumGetArrayTypeP(datum);
 
        /* update according to each SET or RESET item, left to right */
        a = update_proconfig_value(a, set_items);
 
        /* update the tuple */
        memset(repl_repl, false, sizeof(repl_repl));
        repl_repl[Anum_pg_proc_proconfig - 1] = true;
 
        if (a == NULL)
        {
            repl_val[Anum_pg_proc_proconfig - 1] = (Datum) 0;
            repl_null[Anum_pg_proc_proconfig - 1] = true;
        }
        else
        {
            repl_val[Anum_pg_proc_proconfig - 1] = PointerGetDatum(a);
            repl_null[Anum_pg_proc_proconfig - 1] = false;
        }
 
        tup = heap_modify_tuple(tup, RelationGetDescr(rel),
                                repl_val, repl_null, repl_repl);
    }
    /* DO NOT put more touches of procForm below here; it's now dangling. */
 
    /* Do the update */
    CatalogTupleUpdate(rel, &tup->t_self, tup);
 
    InvokeObjectPostAlterHook(ProcedureRelationId, funcOid, 0);
 
    table_close(rel, NoLock);
    heap_freetuple(tup);
 
    return address;
}

References a, aclcheck_error(), ACLCHECK_NOT_OWNER, DefElem::arg, boolVal, CatalogTupleUpdate(), changeDependencyFor(), ObjectAddress::classId, compute_common_attribute(), DatumGetArrayTypeP, defGetNumeric(), DefElem::defname, DEPENDENCY_NORMAL, elog, ereport, errcode(), errmsg(), ERROR, get_func_name(), GETSTRUCT, GetUserId(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, interpret_func_parallel(), interpret_func_support(), interpret_func_volatility(), InvokeObjectPostAlterHook, lfirst, LookupFuncWithArgs(), NameListToString(), NIL, NoLock, object_ownercheck(), ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, PointerGetDatum(), recordDependencyOn(), RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, stmt, superuser(), SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), and update_proconfig_value().

Referenced by ProcessUtilitySlow().

CallStmtResultDesc()

TupleDesc CallStmtResultDesc

(

CallStmt *

stmt

)

Definition at line 2380 of file functioncmds.c.

{
    FuncExpr   *fexpr;
    HeapTuple   tuple;
    TupleDesc   tupdesc;
 
    fexpr = stmt->funcexpr;
 
    tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(fexpr->funcid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for procedure %u", fexpr->funcid);
 
    tupdesc = build_function_result_tupdesc_t(tuple);
 
    ReleaseSysCache(tuple);
 
    /*
     * The result of build_function_result_tupdesc_t has the right column
     * names, but it just has the declared output argument types, which is the
     * wrong thing in polymorphic cases.  Get the correct types by examining
     * stmt->outargs.  We intentionally keep the atttypmod as -1 and the
     * attcollation as the type's default, since that's always the appropriate
     * thing for function outputs; there's no point in considering any
     * additional info available from outargs.  Note that tupdesc is null if
     * there are no outargs.
     */
    if (tupdesc)
    {
        Assert(tupdesc->natts == list_length(stmt->outargs));
        for (int i = 0; i < tupdesc->natts; i++)
        {
            Form_pg_attribute att = TupleDescAttr(tupdesc, i);
            Node       *outarg = (Node *) list_nth(stmt->outargs, i);
 
            TupleDescInitEntry(tupdesc,
                               i + 1,
                               NameStr(att->attname),
                               exprType(outarg),
                               -1,
                               0);
        }
    }
 
    return tupdesc;
}

References Assert, build_function_result_tupdesc_t(), elog, ERROR, exprType(), FuncExpr::funcid, HeapTupleIsValid, i, list_length(), list_nth(), NameStr, TupleDescData::natts, ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache1(), stmt, TupleDescAttr(), and TupleDescInitEntry().

Referenced by UtilityTupleDescriptor().

check_transform_function()

static void check_transform_function ( Form_pg_proc  procstruct )

static

Definition at line 1799 of file functioncmds.c.

{
    if (procstruct->provolatile == PROVOLATILE_VOLATILE)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("transform function must not be volatile")));
    if (procstruct->prokind != PROKIND_FUNCTION)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("transform function must be a normal function")));
    if (procstruct->proretset)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("transform function must not return a set")));
    if (procstruct->pronargs != 1)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("transform function must take one argument")));
    if (procstruct->proargtypes.values[0] != INTERNALOID)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("first argument of transform function must be type %s",
                        "internal")));
}

References ereport, errcode(), errmsg(), and ERROR.

Referenced by CreateTransform().

compute_common_attribute()

static bool compute_common_attribute ( ParseState *  pstate, bool  is_procedure, DefElem *  defel, DefElem **  volatility_item, DefElem **  strict_item, DefElem **  security_item, DefElem **  leakproof_item, List **  set_items, DefElem **  cost_item, DefElem **  rows_item, DefElem **  support_item, DefElem **  parallel_item  )

static

Definition at line 515 of file functioncmds.c.

{
    if (strcmp(defel->defname, "volatility") == 0)
    {
        if (is_procedure)
            goto procedure_error;
        if (*volatility_item)
            errorConflictingDefElem(defel, pstate);
 
        *volatility_item = defel;
    }
    else if (strcmp(defel->defname, "strict") == 0)
    {
        if (is_procedure)
            goto procedure_error;
        if (*strict_item)
            errorConflictingDefElem(defel, pstate);
 
        *strict_item = defel;
    }
    else if (strcmp(defel->defname, "security") == 0)
    {
        if (*security_item)
            errorConflictingDefElem(defel, pstate);
 
        *security_item = defel;
    }
    else if (strcmp(defel->defname, "leakproof") == 0)
    {
        if (is_procedure)
            goto procedure_error;
        if (*leakproof_item)
            errorConflictingDefElem(defel, pstate);
 
        *leakproof_item = defel;
    }
    else if (strcmp(defel->defname, "set") == 0)
    {
        *set_items = lappend(*set_items, defel->arg);
    }
    else if (strcmp(defel->defname, "cost") == 0)
    {
        if (is_procedure)
            goto procedure_error;
        if (*cost_item)
            errorConflictingDefElem(defel, pstate);
 
        *cost_item = defel;
    }
    else if (strcmp(defel->defname, "rows") == 0)
    {
        if (is_procedure)
            goto procedure_error;
        if (*rows_item)
            errorConflictingDefElem(defel, pstate);
 
        *rows_item = defel;
    }
    else if (strcmp(defel->defname, "support") == 0)
    {
        if (is_procedure)
            goto procedure_error;
        if (*support_item)
            errorConflictingDefElem(defel, pstate);
 
        *support_item = defel;
    }
    else if (strcmp(defel->defname, "parallel") == 0)
    {
        if (is_procedure)
            goto procedure_error;
        if (*parallel_item)
            errorConflictingDefElem(defel, pstate);
 
        *parallel_item = defel;
    }
    else
        return false;
 
    /* Recognized an option */
    return true;
 
procedure_error:
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
             errmsg("invalid attribute in procedure definition"),
             parser_errposition(pstate, defel->location)));
    return false;
}

References DefElem::arg, DefElem::defname, ereport, errcode(), errmsg(), ERROR, errorConflictingDefElem(), lappend(), DefElem::location, and parser_errposition().

Referenced by AlterFunction(), and compute_function_attributes().

compute_function_attributes()

static void compute_function_attributes ( ParseState *  pstate, bool  is_procedure, List *  options, List **  as, char **  language, Node **  transform, bool *  windowfunc_p, char *  volatility_p, bool *  strict_p, bool *  security_definer, bool *  leakproof_p, ArrayType **  proconfig, float4 *  procost, float4 *  prorows, Oid *  prosupport, char *  parallel_p  )

static

Definition at line 729 of file functioncmds.c.

{
    ListCell   *option;
    DefElem    *as_item = NULL;
    DefElem    *language_item = NULL;
    DefElem    *transform_item = NULL;
    DefElem    *windowfunc_item = NULL;
    DefElem    *volatility_item = NULL;
    DefElem    *strict_item = NULL;
    DefElem    *security_item = NULL;
    DefElem    *leakproof_item = NULL;
    List       *set_items = NIL;
    DefElem    *cost_item = NULL;
    DefElem    *rows_item = NULL;
    DefElem    *support_item = NULL;
    DefElem    *parallel_item = NULL;
 
    foreach(option, options)
    {
        DefElem    *defel = (DefElem *) lfirst(option);
 
        if (strcmp(defel->defname, "as") == 0)
        {
            if (as_item)
                errorConflictingDefElem(defel, pstate);
            as_item = defel;
        }
        else if (strcmp(defel->defname, "language") == 0)
        {
            if (language_item)
                errorConflictingDefElem(defel, pstate);
            language_item = defel;
        }
        else if (strcmp(defel->defname, "transform") == 0)
        {
            if (transform_item)
                errorConflictingDefElem(defel, pstate);
            transform_item = defel;
        }
        else if (strcmp(defel->defname, "window") == 0)
        {
            if (windowfunc_item)
                errorConflictingDefElem(defel, pstate);
            if (is_procedure)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("invalid attribute in procedure definition"),
                         parser_errposition(pstate, defel->location)));
            windowfunc_item = defel;
        }
        else if (compute_common_attribute(pstate,
                                          is_procedure,
                                          defel,
                                          &volatility_item,
                                          &strict_item,
                                          &security_item,
                                          &leakproof_item,
                                          &set_items,
                                          &cost_item,
                                          &rows_item,
                                          &support_item,
                                          &parallel_item))
        {
            /* recognized common option */
            continue;
        }
        else
            elog(ERROR, "option \"%s\" not recognized",
                 defel->defname);
    }
 
    if (as_item)
        *as = (List *) as_item->arg;
    if (language_item)
        *language = strVal(language_item->arg);
    if (transform_item)
        *transform = transform_item->arg;
    if (windowfunc_item)
        *windowfunc_p = boolVal(windowfunc_item->arg);
    if (volatility_item)
        *volatility_p = interpret_func_volatility(volatility_item);
    if (strict_item)
        *strict_p = boolVal(strict_item->arg);
    if (security_item)
        *security_definer = boolVal(security_item->arg);
    if (leakproof_item)
        *leakproof_p = boolVal(leakproof_item->arg);
    if (set_items)
        *proconfig = update_proconfig_value(NULL, set_items);
    if (cost_item)
    {
        *procost = defGetNumeric(cost_item);
        if (*procost <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("COST must be positive")));
    }
    if (rows_item)
    {
        *prorows = defGetNumeric(rows_item);
        if (*prorows <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("ROWS must be positive")));
    }
    if (support_item)
        *prosupport = interpret_func_support(support_item);
    if (parallel_item)
        *parallel_p = interpret_func_parallel(parallel_item);
}

References DefElem::arg, boolVal, compute_common_attribute(), defGetNumeric(), DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, errorConflictingDefElem(), if(), interpret_func_parallel(), interpret_func_support(), interpret_func_volatility(), lfirst, DefElem::location, NIL, parser_errposition(), strVal, and update_proconfig_value().

Referenced by CreateFunction().

compute_return_type()

static void compute_return_type ( TypeName *  returnType, Oid  languageOid, Oid *  prorettype_p, bool *  returnsSet_p  )

static

Definition at line 88 of file functioncmds.c.

{
    Oid         rettype;
    Type        typtup;
    AclResult   aclresult;
 
    typtup = LookupTypeName(NULL, returnType, NULL, false);
 
    if (typtup)
    {
        if (!((Form_pg_type) GETSTRUCT(typtup))->typisdefined)
        {
            if (languageOid == SQLlanguageId)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("SQL function cannot return shell type %s",
                                TypeNameToString(returnType))));
            else
                ereport(NOTICE,
                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                         errmsg("return type %s is only a shell",
                                TypeNameToString(returnType))));
        }
        rettype = typeTypeId(typtup);
        ReleaseSysCache(typtup);
    }
    else
    {
        char       *typnam = TypeNameToString(returnType);
        Oid         namespaceId;
        char       *typname;
        ObjectAddress address;
 
        /*
         * Only C-coded functions can be I/O functions.  We enforce this
         * restriction here mainly to prevent littering the catalogs with
         * shell types due to simple typos in user-defined function
         * definitions.
         */
        if (languageOid != INTERNALlanguageId &&
            languageOid != ClanguageId)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("type \"%s\" does not exist", typnam)));
 
        /* Reject if there's typmod decoration, too */
        if (returnType->typmods != NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("type modifier cannot be specified for shell type \"%s\"",
                            typnam)));
 
        /* Otherwise, go ahead and make a shell type */
        ereport(NOTICE,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("type \"%s\" is not yet defined", typnam),
                 errdetail("Creating a shell type definition.")));
        namespaceId = QualifiedNameGetCreationNamespace(returnType->names,
                                                        &typname);
        aclresult = object_aclcheck(NamespaceRelationId, namespaceId, GetUserId(),
                                    ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_SCHEMA,
                           get_namespace_name(namespaceId));
        address = TypeShellMake(typname, namespaceId, GetUserId());
        rettype = address.objectId;
        Assert(OidIsValid(rettype));
    }
 
    aclresult = object_aclcheck(TypeRelationId, rettype, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, rettype);
 
    *prorettype_p = rettype;
    *returnsSet_p = returnType->setof;
}

References ACL_CREATE, ACL_USAGE, aclcheck_error(), aclcheck_error_type(), ACLCHECK_OK, Assert, ereport, errcode(), errdetail(), errmsg(), ERROR, get_namespace_name(), GETSTRUCT, GetUserId(), LookupTypeName(), TypeName::names, NIL, NOTICE, object_aclcheck(), OBJECT_SCHEMA, ObjectAddress::objectId, OidIsValid, QualifiedNameGetCreationNamespace(), ReleaseSysCache(), TypeName::setof, TypeNameToString(), TypeShellMake(), typeTypeId(), TypeName::typmods, and typname.

Referenced by CreateFunction().

CreateCast()

ObjectAddress CreateCast

(

CreateCastStmt *

stmt

)

Definition at line 1536 of file functioncmds.c.

{
    Oid         sourcetypeid;
    Oid         targettypeid;
    char        sourcetyptype;
    char        targettyptype;
    Oid         funcid;
    Oid         incastid = InvalidOid;
    Oid         outcastid = InvalidOid;
    int         nargs;
    char        castcontext;
    char        castmethod;
    HeapTuple   tuple;
    AclResult   aclresult;
    ObjectAddress myself;
 
    sourcetypeid = typenameTypeId(NULL, stmt->sourcetype);
    targettypeid = typenameTypeId(NULL, stmt->targettype);
    sourcetyptype = get_typtype(sourcetypeid);
    targettyptype = get_typtype(targettypeid);
 
    /* No pseudo-types allowed */
    if (sourcetyptype == TYPTYPE_PSEUDO)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("source data type %s is a pseudo-type",
                        TypeNameToString(stmt->sourcetype))));
 
    if (targettyptype == TYPTYPE_PSEUDO)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("target data type %s is a pseudo-type",
                        TypeNameToString(stmt->targettype))));
 
    /* Permission check */
    if (!object_ownercheck(TypeRelationId, sourcetypeid, GetUserId())
        && !object_ownercheck(TypeRelationId, targettypeid, GetUserId()))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be owner of type %s or type %s",
                        format_type_be(sourcetypeid),
                        format_type_be(targettypeid))));
 
    aclresult = object_aclcheck(TypeRelationId, sourcetypeid, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, sourcetypeid);
 
    aclresult = object_aclcheck(TypeRelationId, targettypeid, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, targettypeid);
 
    /* Domains are allowed for historical reasons, but we warn */
    if (sourcetyptype == TYPTYPE_DOMAIN)
        ereport(WARNING,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cast will be ignored because the source data type is a domain")));
 
    else if (targettyptype == TYPTYPE_DOMAIN)
        ereport(WARNING,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cast will be ignored because the target data type is a domain")));
 
    /* Determine the cast method */
    if (stmt->func != NULL)
        castmethod = COERCION_METHOD_FUNCTION;
    else if (stmt->inout)
        castmethod = COERCION_METHOD_INOUT;
    else
        castmethod = COERCION_METHOD_BINARY;
 
    if (castmethod == COERCION_METHOD_FUNCTION)
    {
        Form_pg_proc procstruct;
 
        funcid = LookupFuncWithArgs(OBJECT_FUNCTION, stmt->func, false);
 
        tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for function %u", funcid);
 
        procstruct = (Form_pg_proc) GETSTRUCT(tuple);
        nargs = procstruct->pronargs;
        if (nargs < 1 || nargs > 3)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("cast function must take one to three arguments")));
        if (!IsBinaryCoercibleWithCast(sourcetypeid,
                                       procstruct->proargtypes.values[0],
                                       &incastid))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("argument of cast function must match or be binary-coercible from source data type")));
        if (nargs > 1 && procstruct->proargtypes.values[1] != INT4OID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("second argument of cast function must be type %s",
                            "integer")));
        if (nargs > 2 && procstruct->proargtypes.values[2] != BOOLOID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("third argument of cast function must be type %s",
                            "boolean")));
        if (!IsBinaryCoercibleWithCast(procstruct->prorettype,
                                       targettypeid,
                                       &outcastid))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("return data type of cast function must match or be binary-coercible to target data type")));
 
        /*
         * Restricting the volatility of a cast function may or may not be a
         * good idea in the abstract, but it definitely breaks many old
         * user-defined types.  Disable this check --- tgl 2/1/03
         */
#ifdef NOT_USED
        if (procstruct->provolatile == PROVOLATILE_VOLATILE)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("cast function must not be volatile")));
#endif
        if (procstruct->prokind != PROKIND_FUNCTION)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("cast function must be a normal function")));
        if (procstruct->proretset)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("cast function must not return a set")));
 
        ReleaseSysCache(tuple);
    }
    else
    {
        funcid = InvalidOid;
        nargs = 0;
    }
 
    if (castmethod == COERCION_METHOD_BINARY)
    {
        int16       typ1len;
        int16       typ2len;
        bool        typ1byval;
        bool        typ2byval;
        char        typ1align;
        char        typ2align;
 
        /*
         * Must be superuser to create binary-compatible casts, since
         * erroneous casts can easily crash the backend.
         */
        if (!superuser())
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("must be superuser to create a cast WITHOUT FUNCTION")));
 
        /*
         * Also, insist that the types match as to size, alignment, and
         * pass-by-value attributes; this provides at least a crude check that
         * they have similar representations.  A pair of types that fail this
         * test should certainly not be equated.
         */
        get_typlenbyvalalign(sourcetypeid, &typ1len, &typ1byval, &typ1align);
        get_typlenbyvalalign(targettypeid, &typ2len, &typ2byval, &typ2align);
        if (typ1len != typ2len ||
            typ1byval != typ2byval ||
            typ1align != typ2align)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("source and target data types are not physically compatible")));
 
        /*
         * We know that composite, array, range and enum types are never
         * binary-compatible with each other.  They all have OIDs embedded in
         * them.
         *
         * Theoretically you could build a user-defined base type that is
         * binary-compatible with such a type.  But we disallow it anyway, as
         * in practice such a cast is surely a mistake.  You can always work
         * around that by writing a cast function.
         *
         * NOTE: if we ever have a kind of container type that doesn't need to
         * be rejected for this reason, we'd likely need to recursively apply
         * all of these same checks to the contained type(s).
         */
        if (sourcetyptype == TYPTYPE_COMPOSITE ||
            targettyptype == TYPTYPE_COMPOSITE)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("composite data types are not binary-compatible")));
 
        if (OidIsValid(get_element_type(sourcetypeid)) ||
            OidIsValid(get_element_type(targettypeid)))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("array data types are not binary-compatible")));
 
        if (sourcetyptype == TYPTYPE_RANGE ||
            targettyptype == TYPTYPE_RANGE ||
            sourcetyptype == TYPTYPE_MULTIRANGE ||
            targettyptype == TYPTYPE_MULTIRANGE)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("range data types are not binary-compatible")));
 
        if (sourcetyptype == TYPTYPE_ENUM ||
            targettyptype == TYPTYPE_ENUM)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("enum data types are not binary-compatible")));
 
        /*
         * We also disallow creating binary-compatibility casts involving
         * domains.  Casting from a domain to its base type is already
         * allowed, and casting the other way ought to go through domain
         * coercion to permit constraint checking.  Again, if you're intent on
         * having your own semantics for that, create a no-op cast function.
         *
         * NOTE: if we were to relax this, the above checks for composites
         * etc. would have to be modified to look through domains to their
         * base types.
         */
        if (sourcetyptype == TYPTYPE_DOMAIN ||
            targettyptype == TYPTYPE_DOMAIN)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("domain data types must not be marked binary-compatible")));
    }
 
    /*
     * Allow source and target types to be same only for length coercion
     * functions.  We assume a multi-arg function does length coercion.
     */
    if (sourcetypeid == targettypeid && nargs < 2)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("source data type and target data type are the same")));
 
    /* convert CoercionContext enum to char value for castcontext */
    switch (stmt->context)
    {
        case COERCION_IMPLICIT:
            castcontext = COERCION_CODE_IMPLICIT;
            break;
        case COERCION_ASSIGNMENT:
            castcontext = COERCION_CODE_ASSIGNMENT;
            break;
            /* COERCION_PLPGSQL is intentionally not covered here */
        case COERCION_EXPLICIT:
            castcontext = COERCION_CODE_EXPLICIT;
            break;
        default:
            elog(ERROR, "unrecognized CoercionContext: %d", stmt->context);
            castcontext = 0;    /* keep compiler quiet */
            break;
    }
 
    myself = CastCreate(sourcetypeid, targettypeid, funcid, incastid, outcastid,
                        castcontext, castmethod, DEPENDENCY_NORMAL);
    return myself;
}

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, CastCreate(), COERCION_ASSIGNMENT, COERCION_EXPLICIT, COERCION_IMPLICIT, DEPENDENCY_NORMAL, elog, ereport, errcode(), errmsg(), ERROR, format_type_be(), get_element_type(), get_typlenbyvalalign(), get_typtype(), GETSTRUCT, GetUserId(), HeapTupleIsValid, InvalidOid, IsBinaryCoercibleWithCast(), LookupFuncWithArgs(), object_aclcheck(), OBJECT_FUNCTION, object_ownercheck(), ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), SearchSysCache1(), stmt, superuser(), TypeNameToString(), typenameTypeId(), and WARNING.

Referenced by ProcessUtilitySlow().

CreateFunction()

ObjectAddress CreateFunction	(	ParseState *	pstate,
		CreateFunctionStmt *	stmt
	)

Definition at line 1026 of file functioncmds.c.

{
    char       *probin_str;
    char       *prosrc_str;
    Node       *prosqlbody;
    Oid         prorettype;
    bool        returnsSet;
    char       *language;
    Oid         languageOid;
    Oid         languageValidator;
    Node       *transformDefElem = NULL;
    char       *funcname;
    Oid         namespaceId;
    AclResult   aclresult;
    oidvector  *parameterTypes;
    List       *parameterTypes_list = NIL;
    ArrayType  *allParameterTypes;
    ArrayType  *parameterModes;
    ArrayType  *parameterNames;
    List       *inParameterNames_list = NIL;
    List       *parameterDefaults;
    Oid         variadicArgType;
    List       *trftypes_list = NIL;
    ArrayType  *trftypes;
    Oid         requiredResultType;
    bool        isWindowFunc,
                isStrict,
                security,
                isLeakProof;
    char        volatility;
    ArrayType  *proconfig;
    float4      procost;
    float4      prorows;
    Oid         prosupport;
    HeapTuple   languageTuple;
    Form_pg_language languageStruct;
    List       *as_clause;
    char        parallel;
 
    /* Convert list of names to a name and namespace */
    namespaceId = QualifiedNameGetCreationNamespace(stmt->funcname,
                                                    &funcname);
 
    /* Check we have creation rights in target namespace */
    aclresult = object_aclcheck(NamespaceRelationId, namespaceId, GetUserId(), ACL_CREATE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_SCHEMA,
                       get_namespace_name(namespaceId));
 
    /* Set default attributes */
    as_clause = NIL;
    language = NULL;
    isWindowFunc = false;
    isStrict = false;
    security = false;
    isLeakProof = false;
    volatility = PROVOLATILE_VOLATILE;
    proconfig = NULL;
    procost = -1;               /* indicates not set */
    prorows = -1;               /* indicates not set */
    prosupport = InvalidOid;
    parallel = PROPARALLEL_UNSAFE;
 
    /* Extract non-default attributes from stmt->options list */
    compute_function_attributes(pstate,
                                stmt->is_procedure,
                                stmt->options,
                                &as_clause, &language, &transformDefElem,
                                &isWindowFunc, &volatility,
                                &isStrict, &security, &isLeakProof,
                                &proconfig, &procost, &prorows,
                                &prosupport, &parallel);
 
    if (!language)
    {
        if (stmt->sql_body)
            language = "sql";
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("no language specified")));
    }
 
    /* Look up the language and validate permissions */
    languageTuple = SearchSysCache1(LANGNAME, PointerGetDatum(language));
    if (!HeapTupleIsValid(languageTuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("language \"%s\" does not exist", language),
                 (extension_file_exists(language) ?
                  errhint("Use CREATE EXTENSION to load the language into the database.") : 0)));
 
    languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
    languageOid = languageStruct->oid;
 
    if (languageStruct->lanpltrusted)
    {
        /* if trusted language, need USAGE privilege */
        aclresult = object_aclcheck(LanguageRelationId, languageOid, GetUserId(), ACL_USAGE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_LANGUAGE,
                           NameStr(languageStruct->lanname));
    }
    else
    {
        /* if untrusted language, must be superuser */
        if (!superuser())
            aclcheck_error(ACLCHECK_NO_PRIV, OBJECT_LANGUAGE,
                           NameStr(languageStruct->lanname));
    }
 
    languageValidator = languageStruct->lanvalidator;
 
    ReleaseSysCache(languageTuple);
 
    /*
     * Only superuser is allowed to create leakproof functions because
     * leakproof functions can see tuples which have not yet been filtered out
     * by security barrier views or row-level security policies.
     */
    if (isLeakProof && !superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("only superuser can define a leakproof function")));
 
    if (transformDefElem)
    {
        ListCell   *lc;
 
        foreach(lc, castNode(List, transformDefElem))
        {
            Oid         typeid = typenameTypeId(NULL,
                                                lfirst_node(TypeName, lc));
            Oid         elt = get_base_element_type(typeid);
 
            typeid = elt ? elt : typeid;
 
            get_transform_oid(typeid, languageOid, false);
            trftypes_list = lappend_oid(trftypes_list, typeid);
        }
    }
 
    /*
     * Convert remaining parameters of CREATE to form wanted by
     * ProcedureCreate.
     */
    interpret_function_parameter_list(pstate,
                                      stmt->parameters,
                                      languageOid,
                                      stmt->is_procedure ? OBJECT_PROCEDURE : OBJECT_FUNCTION,
                                      &parameterTypes,
                                      &parameterTypes_list,
                                      &allParameterTypes,
                                      &parameterModes,
                                      &parameterNames,
                                      &inParameterNames_list,
                                      &parameterDefaults,
                                      &variadicArgType,
                                      &requiredResultType);
 
    if (stmt->is_procedure)
    {
        Assert(!stmt->returnType);
        prorettype = requiredResultType ? requiredResultType : VOIDOID;
        returnsSet = false;
    }
    else if (stmt->returnType)
    {
        /* explicit RETURNS clause */
        compute_return_type(stmt->returnType, languageOid,
                            &prorettype, &returnsSet);
        if (OidIsValid(requiredResultType) && prorettype != requiredResultType)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("function result type must be %s because of OUT parameters",
                            format_type_be(requiredResultType))));
    }
    else if (OidIsValid(requiredResultType))
    {
        /* default RETURNS clause from OUT parameters */
        prorettype = requiredResultType;
        returnsSet = false;
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                 errmsg("function result type must be specified")));
        /* Alternative possibility: default to RETURNS VOID */
        prorettype = VOIDOID;
        returnsSet = false;
    }
 
    if (trftypes_list != NIL)
    {
        ListCell   *lc;
        Datum      *arr;
        int         i;
 
        arr = palloc(list_length(trftypes_list) * sizeof(Datum));
        i = 0;
        foreach(lc, trftypes_list)
            arr[i++] = ObjectIdGetDatum(lfirst_oid(lc));
        trftypes = construct_array_builtin(arr, list_length(trftypes_list), OIDOID);
    }
    else
    {
        /* store SQL NULL instead of empty array */
        trftypes = NULL;
    }
 
    interpret_AS_clause(languageOid, language, funcname, as_clause, stmt->sql_body,
                        parameterTypes_list, inParameterNames_list,
                        &prosrc_str, &probin_str, &prosqlbody,
                        pstate->p_sourcetext);
 
    /*
     * Set default values for COST and ROWS depending on other parameters;
     * reject ROWS if it's not returnsSet.  NB: pg_dump knows these default
     * values, keep it in sync if you change them.
     */
    if (procost < 0)
    {
        /* SQL and PL-language functions are assumed more expensive */
        if (languageOid == INTERNALlanguageId ||
            languageOid == ClanguageId)
            procost = 1;
        else
            procost = 100;
    }
    if (prorows < 0)
    {
        if (returnsSet)
            prorows = 1000;
        else
            prorows = 0;        /* dummy value if not returnsSet */
    }
    else if (!returnsSet)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("ROWS is not applicable when function does not return a set")));
 
    /*
     * And now that we have all the parameters, and know we're permitted to do
     * so, go ahead and create the function.
     */
    return ProcedureCreate(funcname,
                           namespaceId,
                           stmt->replace,
                           returnsSet,
                           prorettype,
                           GetUserId(),
                           languageOid,
                           languageValidator,
                           prosrc_str,  /* converted to text later */
                           probin_str,  /* converted to text later */
                           prosqlbody,
                           stmt->is_procedure ? PROKIND_PROCEDURE : (isWindowFunc ? PROKIND_WINDOW : PROKIND_FUNCTION),
                           security,
                           isLeakProof,
                           isStrict,
                           volatility,
                           parallel,
                           parameterTypes,
                           PointerGetDatum(allParameterTypes),
                           PointerGetDatum(parameterModes),
                           PointerGetDatum(parameterNames),
                           parameterDefaults,
                           PointerGetDatum(trftypes),
                           PointerGetDatum(proconfig),
                           prosupport,
                           procost,
                           prorows);
}

References ACL_CREATE, ACL_USAGE, aclcheck_error(), ACLCHECK_NO_PRIV, ACLCHECK_OK, Assert, castNode, compute_function_attributes(), compute_return_type(), construct_array_builtin(), ereport, errcode(), errhint(), errmsg(), ERROR, extension_file_exists(), format_type_be(), funcname, get_base_element_type(), get_namespace_name(), get_transform_oid(), GETSTRUCT, GetUserId(), HeapTupleIsValid, i, interpret_AS_clause(), interpret_function_parameter_list(), InvalidOid, lappend_oid(), lfirst_node, lfirst_oid, list_length(), NameStr, NIL, object_aclcheck(), OBJECT_FUNCTION, OBJECT_LANGUAGE, OBJECT_PROCEDURE, OBJECT_SCHEMA, ObjectIdGetDatum(), OidIsValid, ParseState::p_sourcetext, palloc(), PointerGetDatum(), ProcedureCreate(), QualifiedNameGetCreationNamespace(), ReleaseSysCache(), SearchSysCache1(), stmt, superuser(), and typenameTypeId().

Referenced by ProcessUtilitySlow().

CreateTransform()

ObjectAddress CreateTransform

(

CreateTransformStmt *

stmt

)

Definition at line 1829 of file functioncmds.c.

{
    Oid         typeid;
    char        typtype;
    Oid         langid;
    Oid         fromsqlfuncid;
    Oid         tosqlfuncid;
    AclResult   aclresult;
    Form_pg_proc procstruct;
    Datum       values[Natts_pg_transform];
    bool        nulls[Natts_pg_transform] = {0};
    bool        replaces[Natts_pg_transform] = {0};
    Oid         transformid;
    HeapTuple   tuple;
    HeapTuple   newtuple;
    Relation    relation;
    ObjectAddress myself,
                referenced;
    ObjectAddresses *addrs;
    bool        is_replace;
 
    /*
     * Get the type
     */
    typeid = typenameTypeId(NULL, stmt->type_name);
    typtype = get_typtype(typeid);
 
    if (typtype == TYPTYPE_PSEUDO)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("data type %s is a pseudo-type",
                        TypeNameToString(stmt->type_name))));
 
    if (typtype == TYPTYPE_DOMAIN)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("data type %s is a domain",
                        TypeNameToString(stmt->type_name))));
 
    if (!object_ownercheck(TypeRelationId, typeid, GetUserId()))
        aclcheck_error_type(ACLCHECK_NOT_OWNER, typeid);
 
    aclresult = object_aclcheck(TypeRelationId, typeid, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, typeid);
 
    /*
     * Get the language
     */
    langid = get_language_oid(stmt->lang, false);
 
    aclresult = object_aclcheck(LanguageRelationId, langid, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_LANGUAGE, stmt->lang);
 
    /*
     * Get the functions
     */
    if (stmt->fromsql)
    {
        fromsqlfuncid = LookupFuncWithArgs(OBJECT_FUNCTION, stmt->fromsql, false);
 
        if (!object_ownercheck(ProcedureRelationId, fromsqlfuncid, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, NameListToString(stmt->fromsql->objname));
 
        aclresult = object_aclcheck(ProcedureRelationId, fromsqlfuncid, GetUserId(), ACL_EXECUTE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_FUNCTION, NameListToString(stmt->fromsql->objname));
 
        tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(fromsqlfuncid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for function %u", fromsqlfuncid);
        procstruct = (Form_pg_proc) GETSTRUCT(tuple);
        if (procstruct->prorettype != INTERNALOID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("return data type of FROM SQL function must be %s",
                            "internal")));
        check_transform_function(procstruct);
        ReleaseSysCache(tuple);
    }
    else
        fromsqlfuncid = InvalidOid;
 
    if (stmt->tosql)
    {
        tosqlfuncid = LookupFuncWithArgs(OBJECT_FUNCTION, stmt->tosql, false);
 
        if (!object_ownercheck(ProcedureRelationId, tosqlfuncid, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, NameListToString(stmt->tosql->objname));
 
        aclresult = object_aclcheck(ProcedureRelationId, tosqlfuncid, GetUserId(), ACL_EXECUTE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_FUNCTION, NameListToString(stmt->tosql->objname));
 
        tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(tosqlfuncid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for function %u", tosqlfuncid);
        procstruct = (Form_pg_proc) GETSTRUCT(tuple);
        if (procstruct->prorettype != typeid)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("return data type of TO SQL function must be the transform data type")));
        check_transform_function(procstruct);
        ReleaseSysCache(tuple);
    }
    else
        tosqlfuncid = InvalidOid;
 
    /*
     * Ready to go
     */
    values[Anum_pg_transform_trftype - 1] = ObjectIdGetDatum(typeid);
    values[Anum_pg_transform_trflang - 1] = ObjectIdGetDatum(langid);
    values[Anum_pg_transform_trffromsql - 1] = ObjectIdGetDatum(fromsqlfuncid);
    values[Anum_pg_transform_trftosql - 1] = ObjectIdGetDatum(tosqlfuncid);
 
    relation = table_open(TransformRelationId, RowExclusiveLock);
 
    tuple = SearchSysCache2(TRFTYPELANG,
                            ObjectIdGetDatum(typeid),
                            ObjectIdGetDatum(langid));
    if (HeapTupleIsValid(tuple))
    {
        Form_pg_transform form = (Form_pg_transform) GETSTRUCT(tuple);
 
        if (!stmt->replace)
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("transform for type %s language \"%s\" already exists",
                            format_type_be(typeid),
                            stmt->lang)));
 
        replaces[Anum_pg_transform_trffromsql - 1] = true;
        replaces[Anum_pg_transform_trftosql - 1] = true;
 
        newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values, nulls, replaces);
        CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
        transformid = form->oid;
        ReleaseSysCache(tuple);
        is_replace = true;
    }
    else
    {
        transformid = GetNewOidWithIndex(relation, TransformOidIndexId,
                                         Anum_pg_transform_oid);
        values[Anum_pg_transform_oid - 1] = ObjectIdGetDatum(transformid);
        newtuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
        CatalogTupleInsert(relation, newtuple);
        is_replace = false;
    }
 
    if (is_replace)
        deleteDependencyRecordsFor(TransformRelationId, transformid, true);
 
    addrs = new_object_addresses();
 
    /* make dependency entries */
    ObjectAddressSet(myself, TransformRelationId, transformid);
 
    /* dependency on language */
    ObjectAddressSet(referenced, LanguageRelationId, langid);
    add_exact_object_address(&referenced, addrs);
 
    /* dependency on type */
    ObjectAddressSet(referenced, TypeRelationId, typeid);
    add_exact_object_address(&referenced, addrs);
 
    /* dependencies on functions */
    if (OidIsValid(fromsqlfuncid))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, fromsqlfuncid);
        add_exact_object_address(&referenced, addrs);
    }
    if (OidIsValid(tosqlfuncid))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, tosqlfuncid);
        add_exact_object_address(&referenced, addrs);
    }
 
    record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
    free_object_addresses(addrs);
 
    /* dependency on extension */
    recordDependencyOnCurrentExtension(&myself, is_replace);
 
    /* Post creation hook for new transform */
    InvokeObjectPostCreateHook(TransformRelationId, transformid, 0);
 
    heap_freetuple(newtuple);
 
    table_close(relation, RowExclusiveLock);
 
    return myself;
}

References ACL_EXECUTE, ACL_USAGE, aclcheck_error(), aclcheck_error_type(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, add_exact_object_address(), CatalogTupleInsert(), CatalogTupleUpdate(), check_transform_function(), deleteDependencyRecordsFor(), DEPENDENCY_NORMAL, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, format_type_be(), free_object_addresses(), get_language_oid(), get_typtype(), GetNewOidWithIndex(), GETSTRUCT, GetUserId(), heap_form_tuple(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostCreateHook, LookupFuncWithArgs(), NameListToString(), new_object_addresses(), object_aclcheck(), OBJECT_FUNCTION, OBJECT_LANGUAGE, object_ownercheck(), ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, record_object_address_dependencies(), recordDependencyOnCurrentExtension(), RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), SearchSysCache2(), stmt, HeapTupleData::t_self, table_close(), table_open(), TypeNameToString(), typenameTypeId(), and values.

Referenced by ProcessUtilitySlow().

ExecuteCallStmt()

void ExecuteCallStmt	(	CallStmt *	stmt,
		ParamListInfo	params,
		bool	atomic,
		DestReceiver *	dest
	)

Definition at line 2203 of file functioncmds.c.

{
    LOCAL_FCINFO(fcinfo, FUNC_MAX_ARGS);
    ListCell   *lc;
    FuncExpr   *fexpr;
    int         nargs;
    int         i;
    AclResult   aclresult;
    FmgrInfo    flinfo;
    CallContext *callcontext;
    EState     *estate;
    ExprContext *econtext;
    HeapTuple   tp;
    PgStat_FunctionCallUsage fcusage;
    Datum       retval;
 
    fexpr = stmt->funcexpr;
    Assert(fexpr);
    Assert(IsA(fexpr, FuncExpr));
 
    aclresult = object_aclcheck(ProcedureRelationId, fexpr->funcid, GetUserId(), ACL_EXECUTE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_PROCEDURE, get_func_name(fexpr->funcid));
 
    /* Prep the context object we'll pass to the procedure */
    callcontext = makeNode(CallContext);
    callcontext->atomic = atomic;
 
    tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(fexpr->funcid));
    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for function %u", fexpr->funcid);
 
    /*
     * If proconfig is set we can't allow transaction commands because of the
     * way the GUC stacking works: The transaction boundary would have to pop
     * the proconfig setting off the stack.  That restriction could be lifted
     * by redesigning the GUC nesting mechanism a bit.
     */
    if (!heap_attisnull(tp, Anum_pg_proc_proconfig, NULL))
        callcontext->atomic = true;
 
    /*
     * In security definer procedures, we can't allow transaction commands.
     * StartTransaction() insists that the security context stack is empty,
     * and AbortTransaction() resets the security context.  This could be
     * reorganized, but right now it doesn't work.
     */
    if (((Form_pg_proc) GETSTRUCT(tp))->prosecdef)
        callcontext->atomic = true;
 
    ReleaseSysCache(tp);
 
    /* safety check; see ExecInitFunc() */
    nargs = list_length(fexpr->args);
    if (nargs > FUNC_MAX_ARGS)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                 errmsg_plural("cannot pass more than %d argument to a procedure",
                               "cannot pass more than %d arguments to a procedure",
                               FUNC_MAX_ARGS,
                               FUNC_MAX_ARGS)));
 
    /* Initialize function call structure */
    InvokeFunctionExecuteHook(fexpr->funcid);
    fmgr_info(fexpr->funcid, &flinfo);
    fmgr_info_set_expr((Node *) fexpr, &flinfo);
    InitFunctionCallInfoData(*fcinfo, &flinfo, nargs, fexpr->inputcollid,
                             (Node *) callcontext, NULL);
 
    /*
     * Evaluate procedure arguments inside a suitable execution context.  Note
     * we can't free this context till the procedure returns.
     */
    estate = CreateExecutorState();
    estate->es_param_list_info = params;
    econtext = CreateExprContext(estate);
 
    /*
     * If we're called in non-atomic context, we also have to ensure that the
     * argument expressions run with an up-to-date snapshot.  Our caller will
     * have provided a current snapshot in atomic contexts, but not in
     * non-atomic contexts, because the possibility of a COMMIT/ROLLBACK
     * destroying the snapshot makes higher-level management too complicated.
     */
    if (!atomic)
        PushActiveSnapshot(GetTransactionSnapshot());
 
    i = 0;
    foreach(lc, fexpr->args)
    {
        ExprState  *exprstate;
        Datum       val;
        bool        isnull;
 
        exprstate = ExecPrepareExpr(lfirst(lc), estate);
 
        val = ExecEvalExprSwitchContext(exprstate, econtext, &isnull);
 
        fcinfo->args[i].value = val;
        fcinfo->args[i].isnull = isnull;
 
        i++;
    }
 
    /* Get rid of temporary snapshot for arguments, if we made one */
    if (!atomic)
        PopActiveSnapshot();
 
    /* Here we actually call the procedure */
    pgstat_init_function_usage(fcinfo, &fcusage);
    retval = FunctionCallInvoke(fcinfo);
    pgstat_end_function_usage(&fcusage, true);
 
    /* Handle the procedure's outputs */
    if (fexpr->funcresulttype == VOIDOID)
    {
        /* do nothing */
    }
    else if (fexpr->funcresulttype == RECORDOID)
    {
        /* send tuple to client */
        HeapTupleHeader td;
        Oid         tupType;
        int32       tupTypmod;
        TupleDesc   retdesc;
        HeapTupleData rettupdata;
        TupOutputState *tstate;
        TupleTableSlot *slot;
 
        if (fcinfo->isnull)
            elog(ERROR, "procedure returned null record");
 
        /*
         * Ensure there's an active snapshot whilst we execute whatever's
         * involved here.  Note that this is *not* sufficient to make the
         * world safe for TOAST pointers to be included in the returned data:
         * the referenced data could have gone away while we didn't hold a
         * snapshot.  Hence, it's incumbent on PLs that can do COMMIT/ROLLBACK
         * to not return TOAST pointers, unless those pointers were fetched
         * after the last COMMIT/ROLLBACK in the procedure.
         *
         * XXX that is a really nasty, hard-to-test requirement.  Is there a
         * way to remove it?
         */
        EnsurePortalSnapshotExists();
 
        td = DatumGetHeapTupleHeader(retval);
        tupType = HeapTupleHeaderGetTypeId(td);
        tupTypmod = HeapTupleHeaderGetTypMod(td);
        retdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
 
        tstate = begin_tup_output_tupdesc(dest, retdesc,
                                          &TTSOpsHeapTuple);
 
        rettupdata.t_len = HeapTupleHeaderGetDatumLength(td);
        ItemPointerSetInvalid(&(rettupdata.t_self));
        rettupdata.t_tableOid = InvalidOid;
        rettupdata.t_data = td;
 
        slot = ExecStoreHeapTuple(&rettupdata, tstate->slot, false);
        tstate->dest->receiveSlot(slot, tstate->dest);
 
        end_tup_output(tstate);
 
        ReleaseTupleDesc(retdesc);
    }
    else
        elog(ERROR, "unexpected result type for procedure: %u",
             fexpr->funcresulttype);
 
    FreeExecutorState(estate);
}

References ACL_EXECUTE, aclcheck_error(), ACLCHECK_OK, FuncExpr::args, Assert, CallContext::atomic, begin_tup_output_tupdesc(), CreateExecutorState(), CreateExprContext(), DatumGetHeapTupleHeader, generate_unaccent_rules::dest, TupOutputState::dest, elog, end_tup_output(), EnsurePortalSnapshotExists(), ereport, errcode(), errmsg_plural(), ERROR, EState::es_param_list_info, ExecEvalExprSwitchContext(), ExecPrepareExpr(), ExecStoreHeapTuple(), fmgr_info(), fmgr_info_set_expr, FreeExecutorState(), FUNC_MAX_ARGS, FuncExpr::funcid, FunctionCallInvoke, get_func_name(), GETSTRUCT, GetTransactionSnapshot(), GetUserId(), heap_attisnull(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, HeapTupleIsValid, i, InitFunctionCallInfoData, InvalidOid, InvokeFunctionExecuteHook, IsA, ItemPointerSetInvalid(), lfirst, list_length(), LOCAL_FCINFO, lookup_rowtype_tupdesc(), makeNode, object_aclcheck(), OBJECT_PROCEDURE, ObjectIdGetDatum(), pgstat_end_function_usage(), pgstat_init_function_usage(), PopActiveSnapshot(), PushActiveSnapshot(), _DestReceiver::receiveSlot, ReleaseSysCache(), ReleaseTupleDesc, SearchSysCache1(), TupOutputState::slot, stmt, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TTSOpsHeapTuple, and val.

Referenced by standard_ProcessUtility().

ExecuteDoStmt()

void ExecuteDoStmt	(	ParseState *	pstate,
		DoStmt *	stmt,
		bool	atomic
	)

Definition at line 2081 of file functioncmds.c.

{
    InlineCodeBlock *codeblock = makeNode(InlineCodeBlock);
    ListCell   *arg;
    DefElem    *as_item = NULL;
    DefElem    *language_item = NULL;
    char       *language;
    Oid         laninline;
    HeapTuple   languageTuple;
    Form_pg_language languageStruct;
 
    /* Process options we got from gram.y */
    foreach(arg, stmt->args)
    {
        DefElem    *defel = (DefElem *) lfirst(arg);
 
        if (strcmp(defel->defname, "as") == 0)
        {
            if (as_item)
                errorConflictingDefElem(defel, pstate);
            as_item = defel;
        }
        else if (strcmp(defel->defname, "language") == 0)
        {
            if (language_item)
                errorConflictingDefElem(defel, pstate);
            language_item = defel;
        }
        else
            elog(ERROR, "option \"%s\" not recognized",
                 defel->defname);
    }
 
    if (as_item)
        codeblock->source_text = strVal(as_item->arg);
    else
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("no inline code specified")));
 
    /* if LANGUAGE option wasn't specified, use the default */
    if (language_item)
        language = strVal(language_item->arg);
    else
        language = "plpgsql";
 
    /* Look up the language and validate permissions */
    languageTuple = SearchSysCache1(LANGNAME, PointerGetDatum(language));
    if (!HeapTupleIsValid(languageTuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("language \"%s\" does not exist", language),
                 (extension_file_exists(language) ?
                  errhint("Use CREATE EXTENSION to load the language into the database.") : 0)));
 
    languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
    codeblock->langOid = languageStruct->oid;
    codeblock->langIsTrusted = languageStruct->lanpltrusted;
    codeblock->atomic = atomic;
 
    if (languageStruct->lanpltrusted)
    {
        /* if trusted language, need USAGE privilege */
        AclResult   aclresult;
 
        aclresult = object_aclcheck(LanguageRelationId, codeblock->langOid, GetUserId(),
                                    ACL_USAGE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_LANGUAGE,
                           NameStr(languageStruct->lanname));
    }
    else
    {
        /* if untrusted language, must be superuser */
        if (!superuser())
            aclcheck_error(ACLCHECK_NO_PRIV, OBJECT_LANGUAGE,
                           NameStr(languageStruct->lanname));
    }
 
    /* get the handler function's OID */
    laninline = languageStruct->laninline;
    if (!OidIsValid(laninline))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("language \"%s\" does not support inline code execution",
                        NameStr(languageStruct->lanname))));
 
    ReleaseSysCache(languageTuple);
 
    /* execute the inline handler */
    OidFunctionCall1(laninline, PointerGetDatum(codeblock));
}

References ACL_USAGE, aclcheck_error(), ACLCHECK_NO_PRIV, ACLCHECK_OK, arg, DefElem::arg, InlineCodeBlock::atomic, DefElem::defname, elog, ereport, errcode(), errhint(), errmsg(), ERROR, errorConflictingDefElem(), extension_file_exists(), GETSTRUCT, GetUserId(), HeapTupleIsValid, InlineCodeBlock::langIsTrusted, InlineCodeBlock::langOid, lfirst, makeNode, NameStr, object_aclcheck(), OBJECT_LANGUAGE, OidFunctionCall1, OidIsValid, PointerGetDatum(), ReleaseSysCache(), SearchSysCache1(), InlineCodeBlock::source_text, stmt, strVal, and superuser().

Referenced by standard_ProcessUtility().

get_transform_oid()

Oid get_transform_oid	(	Oid	type_id,
		Oid	lang_id,
		bool	missing_ok
	)

Definition at line 2034 of file functioncmds.c.

{
    Oid         oid;
 
    oid = GetSysCacheOid2(TRFTYPELANG, Anum_pg_transform_oid,
                          ObjectIdGetDatum(type_id),
                          ObjectIdGetDatum(lang_id));
    if (!OidIsValid(oid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("transform for type %s language \"%s\" does not exist",
                        format_type_be(type_id),
                        get_language_name(lang_id, false))));
    return oid;
}

References ereport, errcode(), errmsg(), ERROR, format_type_be(), get_language_name(), GetSysCacheOid2, ObjectIdGetDatum(), and OidIsValid.

Referenced by CreateFunction(), get_object_address(), and ProcedureCreate().

interpret_AS_clause()

static void interpret_AS_clause ( Oid  languageOid, const char *  languageName, char *  funcname, List *  as, Node *  sql_body_in, List *  parameterTypes, List *  inParameterNames, char **  prosrc_str_p, char **  probin_str_p, Node **  sql_body_out, const char *  queryString  )

static

Definition at line 866 of file functioncmds.c.

{
    if (!sql_body_in && !as)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                 errmsg("no function body specified")));
 
    if (sql_body_in && as)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                 errmsg("duplicate function body specified")));
 
    if (sql_body_in && languageOid != SQLlanguageId)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                 errmsg("inline SQL function body only valid for language SQL")));
 
    *sql_body_out = NULL;
 
    if (languageOid == ClanguageId)
    {
        /*
         * For "C" language, store the file name in probin and, when given,
         * the link symbol name in prosrc.  If link symbol is omitted,
         * substitute procedure name.  We also allow link symbol to be
         * specified as "-", since that was the habit in PG versions before
         * 8.4, and there might be dump files out there that don't translate
         * that back to "omitted".
         */
        *probin_str_p = strVal(linitial(as));
        if (list_length(as) == 1)
            *prosrc_str_p = funcname;
        else
        {
            *prosrc_str_p = strVal(lsecond(as));
            if (strcmp(*prosrc_str_p, "-") == 0)
                *prosrc_str_p = funcname;
        }
    }
    else if (sql_body_in)
    {
        SQLFunctionParseInfoPtr pinfo;
 
        pinfo = (SQLFunctionParseInfoPtr) palloc0(sizeof(SQLFunctionParseInfo));
 
        pinfo->fname = funcname;
        pinfo->nargs = list_length(parameterTypes);
        pinfo->argtypes = (Oid *) palloc(pinfo->nargs * sizeof(Oid));
        pinfo->argnames = (char **) palloc(pinfo->nargs * sizeof(char *));
        for (int i = 0; i < list_length(parameterTypes); i++)
        {
            char       *s = strVal(list_nth(inParameterNames, i));
 
            pinfo->argtypes[i] = list_nth_oid(parameterTypes, i);
            if (IsPolymorphicType(pinfo->argtypes[i]))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("SQL function with unquoted function body cannot have polymorphic arguments")));
 
            if (s[0] != '\0')
                pinfo->argnames[i] = s;
            else
                pinfo->argnames[i] = NULL;
        }
 
        if (IsA(sql_body_in, List))
        {
            List       *stmts = linitial_node(List, castNode(List, sql_body_in));
            ListCell   *lc;
            List       *transformed_stmts = NIL;
 
            foreach(lc, stmts)
            {
                Node       *stmt = lfirst(lc);
                Query      *q;
                ParseState *pstate = make_parsestate(NULL);
 
                pstate->p_sourcetext = queryString;
                sql_fn_parser_setup(pstate, pinfo);
                q = transformStmt(pstate, stmt);
                if (q->commandType == CMD_UTILITY)
                    ereport(ERROR,
                            errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                            errmsg("%s is not yet supported in unquoted SQL function body",
                                   GetCommandTagName(CreateCommandTag(q->utilityStmt))));
                transformed_stmts = lappend(transformed_stmts, q);
                free_parsestate(pstate);
            }
 
            *sql_body_out = (Node *) list_make1(transformed_stmts);
        }
        else
        {
            Query      *q;
            ParseState *pstate = make_parsestate(NULL);
 
            pstate->p_sourcetext = queryString;
            sql_fn_parser_setup(pstate, pinfo);
            q = transformStmt(pstate, sql_body_in);
            if (q->commandType == CMD_UTILITY)
                ereport(ERROR,
                        errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                        errmsg("%s is not yet supported in unquoted SQL function body",
                               GetCommandTagName(CreateCommandTag(q->utilityStmt))));
            free_parsestate(pstate);
 
            *sql_body_out = (Node *) q;
        }
 
        /*
         * We must put something in prosrc.  For the moment, just record an
         * empty string.  It might be useful to store the original text of the
         * CREATE FUNCTION statement --- but to make actual use of that in
         * error reports, we'd also have to adjust readfuncs.c to not throw
         * away node location fields when reading prosqlbody.
         */
        *prosrc_str_p = pstrdup("");
 
        /* But we definitely don't need probin. */
        *probin_str_p = NULL;
    }
    else
    {
        /* Everything else wants the given string in prosrc. */
        *prosrc_str_p = strVal(linitial(as));
        *probin_str_p = NULL;
 
        if (list_length(as) != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only one AS item needed for language \"%s\"",
                            languageName)));
 
        if (languageOid == INTERNALlanguageId)
        {
            /*
             * In PostgreSQL versions before 6.5, the SQL name of the created
             * function could not be different from the internal name, and
             * "prosrc" wasn't used.  So there is code out there that does
             * CREATE FUNCTION xyz AS '' LANGUAGE internal. To preserve some
             * modicum of backwards compatibility, accept an empty "prosrc"
             * value as meaning the supplied SQL function name.
             */
            if (strlen(*prosrc_str_p) == 0)
                *prosrc_str_p = funcname;
        }
    }
}

References SQLFunctionParseInfo::argnames, SQLFunctionParseInfo::argtypes, castNode, CMD_UTILITY, Query::commandType, CreateCommandTag(), ereport, errcode(), errmsg(), ERROR, SQLFunctionParseInfo::fname, free_parsestate(), funcname, GetCommandTagName(), i, IsA, lappend(), lfirst, linitial, linitial_node, list_length(), list_make1, list_nth(), list_nth_oid(), lsecond, make_parsestate(), SQLFunctionParseInfo::nargs, NIL, ParseState::p_sourcetext, palloc(), palloc0(), pstrdup(), sql_fn_parser_setup(), stmt, strVal, transformStmt(), and Query::utilityStmt.

Referenced by CreateFunction().

interpret_func_parallel()

static char interpret_func_parallel ( DefElem *  defel )

static

Definition at line 635 of file functioncmds.c.

{
    char       *str = strVal(defel->arg);
 
    if (strcmp(str, "safe") == 0)
        return PROPARALLEL_SAFE;
    else if (strcmp(str, "unsafe") == 0)
        return PROPARALLEL_UNSAFE;
    else if (strcmp(str, "restricted") == 0)
        return PROPARALLEL_RESTRICTED;
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("parameter \"parallel\" must be SAFE, RESTRICTED, or UNSAFE")));
        return PROPARALLEL_UNSAFE;  /* keep compiler quiet */
    }
}

References DefElem::arg, ereport, errcode(), errmsg(), ERROR, str, and strVal.

Referenced by AlterFunction(), and compute_function_attributes().

interpret_func_support()

static Oid interpret_func_support ( DefElem *  defel )

static

Definition at line 685 of file functioncmds.c.

{
    List       *procName = defGetQualifiedName(defel);
    Oid         procOid;
    Oid         argList[1];
 
    /*
     * Support functions always take one INTERNAL argument and return
     * INTERNAL.
     */
    argList[0] = INTERNALOID;
 
    procOid = LookupFuncName(procName, 1, argList, true);
    if (!OidIsValid(procOid))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_FUNCTION),
                 errmsg("function %s does not exist",
                        func_signature_string(procName, 1, NIL, argList))));
 
    if (get_func_rettype(procOid) != INTERNALOID)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("support function %s must return type %s",
                        NameListToString(procName), "internal")));
 
    /*
     * Someday we might want an ACL check here; but for now, we insist that
     * you be superuser to specify a support function, so privilege on the
     * support function is moot.
     */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to specify a support function")));
 
    return procOid;
}

References defGetQualifiedName(), ereport, errcode(), errmsg(), ERROR, func_signature_string(), get_func_rettype(), LookupFuncName(), NameListToString(), NIL, OidIsValid, and superuser().

Referenced by AlterFunction(), and compute_function_attributes().

interpret_func_volatility()

static char interpret_func_volatility ( DefElem *  defel )

static

Definition at line 617 of file functioncmds.c.

{
    char       *str = strVal(defel->arg);
 
    if (strcmp(str, "immutable") == 0)
        return PROVOLATILE_IMMUTABLE;
    else if (strcmp(str, "stable") == 0)
        return PROVOLATILE_STABLE;
    else if (strcmp(str, "volatile") == 0)
        return PROVOLATILE_VOLATILE;
    else
    {
        elog(ERROR, "invalid volatility \"%s\"", str);
        return 0;               /* keep compiler quiet */
    }
}

References DefElem::arg, elog, ERROR, str, and strVal.

Referenced by AlterFunction(), and compute_function_attributes().

interpret_function_parameter_list()

void interpret_function_parameter_list	(	ParseState *	pstate,
		List *	parameters,
		Oid	languageOid,
		ObjectType	objtype,
		oidvector **	parameterTypes,
		List **	parameterTypes_list,
		ArrayType **	allParameterTypes,
		ArrayType **	parameterModes,
		ArrayType **	parameterNames,
		List **	inParameterNames_list,
		List **	parameterDefaults,
		Oid *	variadicArgType,
		Oid *	requiredResultType
	)

Definition at line 183 of file functioncmds.c.

{
    int         parameterCount = list_length(parameters);
    Oid        *inTypes;
    int         inCount = 0;
    Datum      *allTypes;
    Datum      *paramModes;
    Datum      *paramNames;
    int         outCount = 0;
    int         varCount = 0;
    bool        have_names = false;
    bool        have_defaults = false;
    ListCell   *x;
    int         i;
 
    *variadicArgType = InvalidOid;  /* default result */
    *requiredResultType = InvalidOid;   /* default result */
 
    inTypes = (Oid *) palloc(parameterCount * sizeof(Oid));
    allTypes = (Datum *) palloc(parameterCount * sizeof(Datum));
    paramModes = (Datum *) palloc(parameterCount * sizeof(Datum));
    paramNames = (Datum *) palloc0(parameterCount * sizeof(Datum));
    *parameterDefaults = NIL;
 
    /* Scan the list and extract data into work arrays */
    i = 0;
    foreach(x, parameters)
    {
        FunctionParameter *fp = (FunctionParameter *) lfirst(x);
        TypeName   *t = fp->argType;
        FunctionParameterMode fpmode = fp->mode;
        bool        isinput = false;
        Oid         toid;
        Type        typtup;
        AclResult   aclresult;
 
        /* For our purposes here, a defaulted mode spec is identical to IN */
        if (fpmode == FUNC_PARAM_DEFAULT)
            fpmode = FUNC_PARAM_IN;
 
        typtup = LookupTypeName(pstate, t, NULL, false);
        if (typtup)
        {
            if (!((Form_pg_type) GETSTRUCT(typtup))->typisdefined)
            {
                /* As above, hard error if language is SQL */
                if (languageOid == SQLlanguageId)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                             errmsg("SQL function cannot accept shell type %s",
                                    TypeNameToString(t)),
                             parser_errposition(pstate, t->location)));
                /* We don't allow creating aggregates on shell types either */
                else if (objtype == OBJECT_AGGREGATE)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                             errmsg("aggregate cannot accept shell type %s",
                                    TypeNameToString(t)),
                             parser_errposition(pstate, t->location)));
                else
                    ereport(NOTICE,
                            (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                             errmsg("argument type %s is only a shell",
                                    TypeNameToString(t)),
                             parser_errposition(pstate, t->location)));
            }
            toid = typeTypeId(typtup);
            ReleaseSysCache(typtup);
        }
        else
        {
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("type %s does not exist",
                            TypeNameToString(t)),
                     parser_errposition(pstate, t->location)));
            toid = InvalidOid;  /* keep compiler quiet */
        }
 
        aclresult = object_aclcheck(TypeRelationId, toid, GetUserId(), ACL_USAGE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error_type(aclresult, toid);
 
        if (t->setof)
        {
            if (objtype == OBJECT_AGGREGATE)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("aggregates cannot accept set arguments"),
                         parser_errposition(pstate, fp->location)));
            else if (objtype == OBJECT_PROCEDURE)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("procedures cannot accept set arguments"),
                         parser_errposition(pstate, fp->location)));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("functions cannot accept set arguments"),
                         parser_errposition(pstate, fp->location)));
        }
 
        /* handle input parameters */
        if (fpmode != FUNC_PARAM_OUT && fpmode != FUNC_PARAM_TABLE)
        {
            /* other input parameters can't follow a VARIADIC parameter */
            if (varCount > 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("VARIADIC parameter must be the last input parameter"),
                         parser_errposition(pstate, fp->location)));
            inTypes[inCount++] = toid;
            isinput = true;
            if (parameterTypes_list)
                *parameterTypes_list = lappend_oid(*parameterTypes_list, toid);
        }
 
        /* handle output parameters */
        if (fpmode != FUNC_PARAM_IN && fpmode != FUNC_PARAM_VARIADIC)
        {
            if (objtype == OBJECT_PROCEDURE)
            {
                /*
                 * We disallow OUT-after-VARIADIC only for procedures.  While
                 * such a case causes no confusion in ordinary function calls,
                 * it would cause confusion in a CALL statement.
                 */
                if (varCount > 0)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                             errmsg("VARIADIC parameter must be the last parameter"),
                             parser_errposition(pstate, fp->location)));
                /* Procedures with output parameters always return RECORD */
                *requiredResultType = RECORDOID;
            }
            else if (outCount == 0) /* save first output param's type */
                *requiredResultType = toid;
            outCount++;
        }
 
        if (fpmode == FUNC_PARAM_VARIADIC)
        {
            *variadicArgType = toid;
            varCount++;
            /* validate variadic parameter type */
            switch (toid)
            {
                case ANYARRAYOID:
                case ANYCOMPATIBLEARRAYOID:
                case ANYOID:
                    /* okay */
                    break;
                default:
                    if (!OidIsValid(get_element_type(toid)))
                        ereport(ERROR,
                                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                                 errmsg("VARIADIC parameter must be an array"),
                                 parser_errposition(pstate, fp->location)));
                    break;
            }
        }
 
        allTypes[i] = ObjectIdGetDatum(toid);
 
        paramModes[i] = CharGetDatum(fpmode);
 
        if (fp->name && fp->name[0])
        {
            ListCell   *px;
 
            /*
             * As of Postgres 9.0 we disallow using the same name for two
             * input or two output function parameters.  Depending on the
             * function's language, conflicting input and output names might
             * be bad too, but we leave it to the PL to complain if so.
             */
            foreach(px, parameters)
            {
                FunctionParameter *prevfp = (FunctionParameter *) lfirst(px);
                FunctionParameterMode prevfpmode;
 
                if (prevfp == fp)
                    break;
                /* as above, default mode is IN */
                prevfpmode = prevfp->mode;
                if (prevfpmode == FUNC_PARAM_DEFAULT)
                    prevfpmode = FUNC_PARAM_IN;
                /* pure in doesn't conflict with pure out */
                if ((fpmode == FUNC_PARAM_IN ||
                     fpmode == FUNC_PARAM_VARIADIC) &&
                    (prevfpmode == FUNC_PARAM_OUT ||
                     prevfpmode == FUNC_PARAM_TABLE))
                    continue;
                if ((prevfpmode == FUNC_PARAM_IN ||
                     prevfpmode == FUNC_PARAM_VARIADIC) &&
                    (fpmode == FUNC_PARAM_OUT ||
                     fpmode == FUNC_PARAM_TABLE))
                    continue;
                if (prevfp->name && prevfp->name[0] &&
                    strcmp(prevfp->name, fp->name) == 0)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                             errmsg("parameter name \"%s\" used more than once",
                                    fp->name),
                             parser_errposition(pstate, fp->location)));
            }
 
            paramNames[i] = CStringGetTextDatum(fp->name);
            have_names = true;
        }
 
        if (inParameterNames_list)
            *inParameterNames_list = lappend(*inParameterNames_list, makeString(fp->name ? fp->name : pstrdup("")));
 
        if (fp->defexpr)
        {
            Node       *def;
 
            if (!isinput)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("only input parameters can have default values"),
                         parser_errposition(pstate, fp->location)));
 
            def = transformExpr(pstate, fp->defexpr,
                                EXPR_KIND_FUNCTION_DEFAULT);
            def = coerce_to_specific_type(pstate, def, toid, "DEFAULT");
            assign_expr_collations(pstate, def);
 
            /*
             * Make sure no variables are referred to (this is probably dead
             * code now that add_missing_from is history).
             */
            if (pstate->p_rtable != NIL ||
                contain_var_clause(def))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                         errmsg("cannot use table references in parameter default value"),
                         parser_errposition(pstate, fp->location)));
 
            /*
             * transformExpr() should have already rejected subqueries,
             * aggregates, and window functions, based on the EXPR_KIND_ for a
             * default expression.
             *
             * It can't return a set either --- but coerce_to_specific_type
             * already checked that for us.
             *
             * Note: the point of these restrictions is to ensure that an
             * expression that, on its face, hasn't got subplans, aggregates,
             * etc cannot suddenly have them after function default arguments
             * are inserted.
             */
 
            *parameterDefaults = lappend(*parameterDefaults, def);
            have_defaults = true;
        }
        else
        {
            if (isinput && have_defaults)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("input parameters after one with a default value must also have defaults"),
                         parser_errposition(pstate, fp->location)));
 
            /*
             * For procedures, we also can't allow OUT parameters after one
             * with a default, because the same sort of confusion arises in a
             * CALL statement.
             */
            if (objtype == OBJECT_PROCEDURE && have_defaults)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("procedure OUT parameters cannot appear after one with a default value"),
                         parser_errposition(pstate, fp->location)));
        }
 
        i++;
    }
 
    /* Now construct the proper outputs as needed */
    *parameterTypes = buildoidvector(inTypes, inCount);
 
    if (outCount > 0 || varCount > 0)
    {
        *allParameterTypes = construct_array_builtin(allTypes, parameterCount, OIDOID);
        *parameterModes = construct_array_builtin(paramModes, parameterCount, CHAROID);
        if (outCount > 1)
            *requiredResultType = RECORDOID;
        /* otherwise we set requiredResultType correctly above */
    }
    else
    {
        *allParameterTypes = NULL;
        *parameterModes = NULL;
    }
 
    if (have_names)
    {
        for (i = 0; i < parameterCount; i++)
        {
            if (paramNames[i] == PointerGetDatum(NULL))
                paramNames[i] = CStringGetTextDatum("");
        }
        *parameterNames = construct_array_builtin(paramNames, parameterCount, TEXTOID);
    }
    else
        *parameterNames = NULL;
}

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, FunctionParameter::argType, assign_expr_collations(), buildoidvector(), CharGetDatum(), coerce_to_specific_type(), construct_array_builtin(), contain_var_clause(), CStringGetTextDatum, FunctionParameter::defexpr, ereport, errcode(), errmsg(), ERROR, EXPR_KIND_FUNCTION_DEFAULT, FUNC_PARAM_DEFAULT, FUNC_PARAM_IN, FUNC_PARAM_OUT, FUNC_PARAM_TABLE, FUNC_PARAM_VARIADIC, get_element_type(), GETSTRUCT, GetUserId(), i, InvalidOid, lappend(), lappend_oid(), lfirst, list_length(), TypeName::location, FunctionParameter::location, LookupTypeName(), makeString(), FunctionParameter::mode, FunctionParameter::name, NIL, NOTICE, object_aclcheck(), OBJECT_AGGREGATE, OBJECT_PROCEDURE, ObjectIdGetDatum(), OidIsValid, ParseState::p_rtable, palloc(), palloc0(), parser_errposition(), PointerGetDatum(), pstrdup(), px(), ReleaseSysCache(), TypeName::setof, transformExpr(), TypeNameToString(), typeTypeId(), and x.

Referenced by CreateFunction(), and DefineAggregate().

IsThereFunctionInNamespace()

void IsThereFunctionInNamespace	(	const char *	proname,
		int	pronargs,
		oidvector *	proargtypes,
		Oid	nspOid
	)

Definition at line 2058 of file functioncmds.c.

{
    /* check for duplicate name (more friendly than unique-index failure) */
    if (SearchSysCacheExists3(PROCNAMEARGSNSP,
                              CStringGetDatum(proname),
                              PointerGetDatum(proargtypes),
                              ObjectIdGetDatum(nspOid)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_FUNCTION),
                 errmsg("function %s already exists in schema \"%s\"",
                        funcname_signature_string(proname, pronargs,
                                                  NIL, proargtypes->values),
                        get_namespace_name(nspOid))));
}

References CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, funcname_signature_string(), get_namespace_name(), NIL, ObjectIdGetDatum(), PointerGetDatum(), proname, pronargs, SearchSysCacheExists3, and oidvector::values.

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

RemoveFunctionById()

void RemoveFunctionById

(

Oid

funcOid

)

Definition at line 1308 of file functioncmds.c.

{
    Relation    relation;
    HeapTuple   tup;
    char        prokind;
 
    /*
     * Delete the pg_proc tuple.
     */
    relation = table_open(ProcedureRelationId, RowExclusiveLock);
 
    tup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcOid));
    if (!HeapTupleIsValid(tup)) /* should not happen */
        elog(ERROR, "cache lookup failed for function %u", funcOid);
 
    prokind = ((Form_pg_proc) GETSTRUCT(tup))->prokind;
 
    CatalogTupleDelete(relation, &tup->t_self);
 
    ReleaseSysCache(tup);
 
    table_close(relation, RowExclusiveLock);
 
    pgstat_drop_function(funcOid);
 
    /*
     * If there's a pg_aggregate tuple, delete that too.
     */
    if (prokind == PROKIND_AGGREGATE)
    {
        relation = table_open(AggregateRelationId, RowExclusiveLock);
 
        tup = SearchSysCache1(AGGFNOID, ObjectIdGetDatum(funcOid));
        if (!HeapTupleIsValid(tup)) /* should not happen */
            elog(ERROR, "cache lookup failed for pg_aggregate tuple for function %u", funcOid);
 
        CatalogTupleDelete(relation, &tup->t_self);
 
        ReleaseSysCache(tup);
 
        table_close(relation, RowExclusiveLock);
    }
}

References CatalogTupleDelete(), elog, ERROR, GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum(), pgstat_drop_function(), ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().

update_proconfig_value()

static ArrayType * update_proconfig_value ( ArrayType *  a, List *  set_items  )

static

Definition at line 660 of file functioncmds.c.

{
    ListCell   *l;
 
    foreach(l, set_items)
    {
        VariableSetStmt *sstmt = lfirst_node(VariableSetStmt, l);
 
        if (sstmt->kind == VAR_RESET_ALL)
            a = NULL;
        else
        {
            char       *valuestr = ExtractSetVariableArgs(sstmt);
 
            if (valuestr)
                a = GUCArrayAdd(a, sstmt->name, valuestr);
            else                /* RESET */
                a = GUCArrayDelete(a, sstmt->name);
        }
    }
 
    return a;
}

References a, ExtractSetVariableArgs(), GUCArrayAdd(), GUCArrayDelete(), VariableSetStmt::kind, lfirst_node, VariableSetStmt::name, and VAR_RESET_ALL.

Referenced by AlterFunction(), and compute_function_attributes().