pl_handler.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * pl_handler.c     - Handler for the PL/pgSQL
 *            procedural language
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/pl/plpgsql/src/pl_handler.c
 *
 *-------------------------------------------------------------------------
 */
 
#include "postgres.h"
 
#include "access/htup_details.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "plpgsql.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
#include "utils/varlena.h"
 
static bool plpgsql_extra_checks_check_hook(char **newvalue, void **extra, GucSource source);
static void plpgsql_extra_warnings_assign_hook(const char *newvalue, void *extra);
static void plpgsql_extra_errors_assign_hook(const char *newvalue, void *extra);
 
PG_MODULE_MAGIC_EXT(
                    .name = "plpgsql",
                    .version = PG_VERSION
);
 
/* Custom GUC variable */
static const struct config_enum_entry variable_conflict_options[] = {
    {"error", PLPGSQL_RESOLVE_ERROR, false},
    {"use_variable", PLPGSQL_RESOLVE_VARIABLE, false},
    {"use_column", PLPGSQL_RESOLVE_COLUMN, false},
    {NULL, 0, false}
};
 
int         plpgsql_variable_conflict = PLPGSQL_RESOLVE_ERROR;
 
bool        plpgsql_print_strict_params = false;
 
bool        plpgsql_check_asserts = true;
 
static char *plpgsql_extra_warnings_string = NULL;
static char *plpgsql_extra_errors_string = NULL;
int         plpgsql_extra_warnings;
int         plpgsql_extra_errors;
 
/* Hook for plugins */
PLpgSQL_plugin **plpgsql_plugin_ptr = NULL;
 
 
static bool
plpgsql_extra_checks_check_hook(char **newvalue, void **extra, GucSource source)
{
    char       *rawstring;
    List       *elemlist;
    ListCell   *l;
    int         extrachecks = 0;
    int        *myextra;
 
    if (pg_strcasecmp(*newvalue, "all") == 0)
        extrachecks = PLPGSQL_XCHECK_ALL;
    else if (pg_strcasecmp(*newvalue, "none") == 0)
        extrachecks = PLPGSQL_XCHECK_NONE;
    else
    {
        /* Need a modifiable copy of string */
        rawstring = pstrdup(*newvalue);
 
        /* Parse string into list of identifiers */
        if (!SplitIdentifierString(rawstring, ',', &elemlist))
        {
            /* syntax error in list */
            GUC_check_errdetail("List syntax is invalid.");
            pfree(rawstring);
            list_free(elemlist);
            return false;
        }
 
        foreach(l, elemlist)
        {
            char       *tok = (char *) lfirst(l);
 
            if (pg_strcasecmp(tok, "shadowed_variables") == 0)
                extrachecks |= PLPGSQL_XCHECK_SHADOWVAR;
            else if (pg_strcasecmp(tok, "too_many_rows") == 0)
                extrachecks |= PLPGSQL_XCHECK_TOOMANYROWS;
            else if (pg_strcasecmp(tok, "strict_multi_assignment") == 0)
                extrachecks |= PLPGSQL_XCHECK_STRICTMULTIASSIGNMENT;
            else if (pg_strcasecmp(tok, "all") == 0 || pg_strcasecmp(tok, "none") == 0)
            {
                GUC_check_errdetail("Key word \"%s\" cannot be combined with other key words.", tok);
                pfree(rawstring);
                list_free(elemlist);
                return false;
            }
            else
            {
                GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
                pfree(rawstring);
                list_free(elemlist);
                return false;
            }
        }
 
        pfree(rawstring);
        list_free(elemlist);
    }
 
    myextra = (int *) guc_malloc(LOG, sizeof(int));
    if (!myextra)
        return false;
    *myextra = extrachecks;
    *extra = myextra;
 
    return true;
}
 
static void
plpgsql_extra_warnings_assign_hook(const char *newvalue, void *extra)
{
    plpgsql_extra_warnings = *((int *) extra);
}
 
static void
plpgsql_extra_errors_assign_hook(const char *newvalue, void *extra)
{
    plpgsql_extra_errors = *((int *) extra);
}
 
 
/*
 * _PG_init()           - library load-time initialization
 *
 * DO NOT make this static nor change its name!
 */
void
_PG_init(void)
{
    /* Be sure we do initialization only once (should be redundant now) */
    static bool inited = false;
 
    if (inited)
        return;
 
    pg_bindtextdomain(TEXTDOMAIN);
 
    DefineCustomEnumVariable("plpgsql.variable_conflict",
                             gettext_noop("Sets handling of conflicts between PL/pgSQL variable names and table column names."),
                             NULL,
                             &plpgsql_variable_conflict,
                             PLPGSQL_RESOLVE_ERROR,
                             variable_conflict_options,
                             PGC_SUSET, 0,
                             NULL, NULL, NULL);
 
    DefineCustomBoolVariable("plpgsql.print_strict_params",
                             gettext_noop("Print information about parameters in the DETAIL part of the error messages generated on INTO ... STRICT failures."),
                             NULL,
                             &plpgsql_print_strict_params,
                             false,
                             PGC_USERSET, 0,
                             NULL, NULL, NULL);
 
    DefineCustomBoolVariable("plpgsql.check_asserts",
                             gettext_noop("Perform checks given in ASSERT statements."),
                             NULL,
                             &plpgsql_check_asserts,
                             true,
                             PGC_USERSET, 0,
                             NULL, NULL, NULL);
 
    DefineCustomStringVariable("plpgsql.extra_warnings",
                               gettext_noop("List of programming constructs that should produce a warning."),
                               NULL,
                               &plpgsql_extra_warnings_string,
                               "none",
                               PGC_USERSET, GUC_LIST_INPUT,
                               plpgsql_extra_checks_check_hook,
                               plpgsql_extra_warnings_assign_hook,
                               NULL);
 
    DefineCustomStringVariable("plpgsql.extra_errors",
                               gettext_noop("List of programming constructs that should produce an error."),
                               NULL,
                               &plpgsql_extra_errors_string,
                               "none",
                               PGC_USERSET, GUC_LIST_INPUT,
                               plpgsql_extra_checks_check_hook,
                               plpgsql_extra_errors_assign_hook,
                               NULL);
 
    MarkGUCPrefixReserved("plpgsql");
 
    RegisterXactCallback(plpgsql_xact_cb, NULL);
    RegisterSubXactCallback(plpgsql_subxact_cb, NULL);
 
    /* Set up a rendezvous point with optional instrumentation plugin */
    plpgsql_plugin_ptr = (PLpgSQL_plugin **) find_rendezvous_variable("PLpgSQL_plugin");
 
    inited = true;
}
 
/* ----------
 * plpgsql_call_handler
 *
 * The PostgreSQL function manager and trigger manager
 * call this function for execution of PL/pgSQL procedures.
 * ----------
 */
PG_FUNCTION_INFO_V1(plpgsql_call_handler);
 
Datum
plpgsql_call_handler(PG_FUNCTION_ARGS)
{
    bool        nonatomic;
    PLpgSQL_function *func;
    PLpgSQL_execstate *save_cur_estate;
    ResourceOwner procedure_resowner;
    volatile Datum retval = (Datum) 0;
    int         rc;
 
    nonatomic = fcinfo->context &&
        IsA(fcinfo->context, CallContext) &&
        !castNode(CallContext, fcinfo->context)->atomic;
 
    /*
     * Connect to SPI manager
     */
    SPI_connect_ext(nonatomic ? SPI_OPT_NONATOMIC : 0);
 
    /* Find or compile the function */
    func = plpgsql_compile(fcinfo, false);
 
    /* Must save and restore prior value of cur_estate */
    save_cur_estate = func->cur_estate;
 
    /* Mark the function as busy, so it can't be deleted from under us */
    func->cfunc.use_count++;
 
    /*
     * If we'll need a procedure-lifespan resowner to execute any CALL or DO
     * statements, create it now.  Since this resowner is not tied to any
     * parent, failing to free it would result in process-lifespan leaks.
     * Therefore, be very wary of adding any code between here and the PG_TRY
     * block.
     */
    procedure_resowner =
        (nonatomic && func->requires_procedure_resowner) ?
        ResourceOwnerCreate(NULL, "PL/pgSQL procedure resources") : NULL;
 
    PG_TRY();
    {
        /*
         * Determine if called as function or trigger and call appropriate
         * subhandler
         */
        if (CALLED_AS_TRIGGER(fcinfo))
            retval = PointerGetDatum(plpgsql_exec_trigger(func,
                                                          (TriggerData *) fcinfo->context));
        else if (CALLED_AS_EVENT_TRIGGER(fcinfo))
        {
            plpgsql_exec_event_trigger(func,
                                       (EventTriggerData *) fcinfo->context);
            /* there's no return value in this case */
        }
        else
            retval = plpgsql_exec_function(func, fcinfo,
                                           NULL, NULL,
                                           procedure_resowner,
                                           !nonatomic);
    }
    PG_FINALLY();
    {
        /* Decrement use-count, restore cur_estate */
        func->cfunc.use_count--;
        func->cur_estate = save_cur_estate;
 
        /* Be sure to release the procedure resowner if any */
        if (procedure_resowner)
        {
            ReleaseAllPlanCacheRefsInOwner(procedure_resowner);
            ResourceOwnerDelete(procedure_resowner);
        }
    }
    PG_END_TRY();
 
    /*
     * Disconnect from SPI manager
     */
    if ((rc = SPI_finish()) != SPI_OK_FINISH)
        elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(rc));
 
    return retval;
}
 
/* ----------
 * plpgsql_inline_handler
 *
 * Called by PostgreSQL to execute an anonymous code block
 * ----------
 */
PG_FUNCTION_INFO_V1(plpgsql_inline_handler);
 
Datum
plpgsql_inline_handler(PG_FUNCTION_ARGS)
{
    LOCAL_FCINFO(fake_fcinfo, 0);
    InlineCodeBlock *codeblock = castNode(InlineCodeBlock, DatumGetPointer(PG_GETARG_DATUM(0)));
    PLpgSQL_function *func;
    FmgrInfo    flinfo;
    EState     *simple_eval_estate;
    ResourceOwner simple_eval_resowner;
    Datum       retval;
    int         rc;
 
    /*
     * Connect to SPI manager
     */
    SPI_connect_ext(codeblock->atomic ? 0 : SPI_OPT_NONATOMIC);
 
    /* Compile the anonymous code block */
    func = plpgsql_compile_inline(codeblock->source_text);
 
    /* Mark the function as busy, just pro forma */
    func->cfunc.use_count++;
 
    /*
     * Set up a fake fcinfo with just enough info to satisfy
     * plpgsql_exec_function().  In particular note that this sets things up
     * with no arguments passed.
     */
    MemSet(fake_fcinfo, 0, SizeForFunctionCallInfo(0));
    MemSet(&flinfo, 0, sizeof(flinfo));
    fake_fcinfo->flinfo = &flinfo;
    flinfo.fn_oid = InvalidOid;
    flinfo.fn_mcxt = CurrentMemoryContext;
 
    /*
     * Create a private EState and resowner for simple-expression execution.
     * Notice that these are NOT tied to transaction-level resources; they
     * must survive any COMMIT/ROLLBACK the DO block executes, since we will
     * unconditionally try to clean them up below.  (Hence, be wary of adding
     * anything that could fail between here and the PG_TRY block.)  See the
     * comments for shared_simple_eval_estate.
     *
     * Because this resowner isn't tied to the calling transaction, we can
     * also use it as the "procedure" resowner for any CALL statements.  That
     * helps reduce the opportunities for failure here.
     */
    simple_eval_estate = CreateExecutorState();
    simple_eval_resowner =
        ResourceOwnerCreate(NULL, "PL/pgSQL DO block simple expressions");
 
    /* And run the function */
    PG_TRY();
    {
        retval = plpgsql_exec_function(func, fake_fcinfo,
                                       simple_eval_estate,
                                       simple_eval_resowner,
                                       simple_eval_resowner,    /* see above */
                                       codeblock->atomic);
    }
    PG_CATCH();
    {
        /*
         * We need to clean up what would otherwise be long-lived resources
         * accumulated by the failed DO block, principally cached plans for
         * statements (which can be flushed by plpgsql_free_function_memory),
         * execution trees for simple expressions, which are in the private
         * EState, and cached-plan refcounts held by the private resowner.
         *
         * Before releasing the private EState, we must clean up any
         * simple_econtext_stack entries pointing into it, which we can do by
         * invoking the subxact callback.  (It will be called again later if
         * some outer control level does a subtransaction abort, but no harm
         * is done.)  We cheat a bit knowing that plpgsql_subxact_cb does not
         * pay attention to its parentSubid argument.
         */
        plpgsql_subxact_cb(SUBXACT_EVENT_ABORT_SUB,
                           GetCurrentSubTransactionId(),
                           0, NULL);
 
        /* Clean up the private EState and resowner */
        FreeExecutorState(simple_eval_estate);
        ReleaseAllPlanCacheRefsInOwner(simple_eval_resowner);
        ResourceOwnerDelete(simple_eval_resowner);
 
        /* Function should now have no remaining use-counts ... */
        func->cfunc.use_count--;
        Assert(func->cfunc.use_count == 0);
 
        /* ... so we can free subsidiary storage */
        plpgsql_free_function_memory(func);
 
        /* And propagate the error */
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    /* Clean up the private EState and resowner */
    FreeExecutorState(simple_eval_estate);
    ReleaseAllPlanCacheRefsInOwner(simple_eval_resowner);
    ResourceOwnerDelete(simple_eval_resowner);
 
    /* Function should now have no remaining use-counts ... */
    func->cfunc.use_count--;
    Assert(func->cfunc.use_count == 0);
 
    /* ... so we can free subsidiary storage */
    plpgsql_free_function_memory(func);
 
    /*
     * Disconnect from SPI manager
     */
    if ((rc = SPI_finish()) != SPI_OK_FINISH)
        elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(rc));
 
    return retval;
}
 
/* ----------
 * plpgsql_validator
 *
 * This function attempts to validate a PL/pgSQL function at
 * CREATE FUNCTION time.
 * ----------
 */
PG_FUNCTION_INFO_V1(plpgsql_validator);
 
Datum
plpgsql_validator(PG_FUNCTION_ARGS)
{
    Oid         funcoid = PG_GETARG_OID(0);
    HeapTuple   tuple;
    Form_pg_proc proc;
    char        functyptype;
    int         numargs;
    Oid        *argtypes;
    char      **argnames;
    char       *argmodes;
    bool        is_dml_trigger = false;
    bool        is_event_trigger = false;
    int         i;
 
    if (!CheckFunctionValidatorAccess(fcinfo->flinfo->fn_oid, funcoid))
        PG_RETURN_VOID();
 
    /* Get the new function's pg_proc entry */
    tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcoid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for function %u", funcoid);
    proc = (Form_pg_proc) GETSTRUCT(tuple);
 
    functyptype = get_typtype(proc->prorettype);
 
    /* Disallow pseudotype result */
    /* except for TRIGGER, EVTTRIGGER, RECORD, VOID, or polymorphic */
    if (functyptype == TYPTYPE_PSEUDO)
    {
        if (proc->prorettype == TRIGGEROID)
            is_dml_trigger = true;
        else if (proc->prorettype == EVENT_TRIGGEROID)
            is_event_trigger = true;
        else if (proc->prorettype != RECORDOID &&
                 proc->prorettype != VOIDOID &&
                 !IsPolymorphicType(proc->prorettype))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("PL/pgSQL functions cannot return type %s",
                            format_type_be(proc->prorettype))));
    }
 
    /* Disallow pseudotypes in arguments (either IN or OUT) */
    /* except for RECORD and polymorphic */
    numargs = get_func_arg_info(tuple,
                                &argtypes, &argnames, &argmodes);
    for (i = 0; i < numargs; i++)
    {
        if (get_typtype(argtypes[i]) == TYPTYPE_PSEUDO)
        {
            if (argtypes[i] != RECORDOID &&
                !IsPolymorphicType(argtypes[i]))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("PL/pgSQL functions cannot accept type %s",
                                format_type_be(argtypes[i]))));
        }
    }
 
    /* Postpone body checks if !check_function_bodies */
    if (check_function_bodies)
    {
        LOCAL_FCINFO(fake_fcinfo, 0);
        FmgrInfo    flinfo;
        int         rc;
        TriggerData trigdata;
        EventTriggerData etrigdata;
 
        /*
         * Connect to SPI manager (is this needed for compilation?)
         */
        SPI_connect();
 
        /*
         * Set up a fake fcinfo with just enough info to satisfy
         * plpgsql_compile().
         */
        MemSet(fake_fcinfo, 0, SizeForFunctionCallInfo(0));
        MemSet(&flinfo, 0, sizeof(flinfo));
        fake_fcinfo->flinfo = &flinfo;
        flinfo.fn_oid = funcoid;
        flinfo.fn_mcxt = CurrentMemoryContext;
        if (is_dml_trigger)
        {
            MemSet(&trigdata, 0, sizeof(trigdata));
            trigdata.type = T_TriggerData;
            fake_fcinfo->context = (Node *) &trigdata;
        }
        else if (is_event_trigger)
        {
            MemSet(&etrigdata, 0, sizeof(etrigdata));
            etrigdata.type = T_EventTriggerData;
            fake_fcinfo->context = (Node *) &etrigdata;
        }
 
        /* Test-compile the function */
        plpgsql_compile(fake_fcinfo, true);
 
        /*
         * Disconnect from SPI manager
         */
        if ((rc = SPI_finish()) != SPI_OK_FINISH)
            elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(rc));
    }
 
    ReleaseSysCache(tuple);
 
    PG_RETURN_VOID();
}