plsample.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * plsample.c
 *    Handler for the PL/Sample procedural language
 *
 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *      src/test/modules/plsample/plsample.c
 *
 *-------------------------------------------------------------------------
 */
 
#include "postgres.h"
 
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "commands/event_trigger.h"
#include "commands/trigger.h"
#include "executor/spi.h"
#include "funcapi.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
 
PG_MODULE_MAGIC;
 
PG_FUNCTION_INFO_V1(plsample_call_handler);
 
static Datum plsample_func_handler(PG_FUNCTION_ARGS);
static HeapTuple plsample_trigger_handler(PG_FUNCTION_ARGS);
 
/*
 * Handle function, procedure, and trigger calls.
 */
Datum
plsample_call_handler(PG_FUNCTION_ARGS)
{
    Datum       retval = (Datum) 0;
 
    /*
     * Many languages will require cleanup that happens even in the event of
     * an error.  That can happen in the PG_FINALLY block.  If none is needed,
     * this PG_TRY construct can be omitted.
     */
    PG_TRY();
    {
        /*
         * Determine if called as function or trigger and call appropriate
         * subhandler.
         */
        if (CALLED_AS_TRIGGER(fcinfo))
        {
            /*
             * This function has been called as a trigger function, where
             * (TriggerData *) fcinfo->context includes the information of the
             * context.
             */
            retval = PointerGetDatum(plsample_trigger_handler(fcinfo));
        }
        else if (CALLED_AS_EVENT_TRIGGER(fcinfo))
        {
            /*
             * This function is called as an event trigger function, where
             * (EventTriggerData *) fcinfo->context includes the information
             * of the context.
             *
             * TODO: provide an example handler.
             */
        }
        else
        {
            /* Regular function handler */
            retval = plsample_func_handler(fcinfo);
        }
    }
    PG_FINALLY();
    {
    }
    PG_END_TRY();
 
    return retval;
}
 
/*
 * plsample_func_handler
 *
 * Function called by the call handler for function execution.
 */
static Datum
plsample_func_handler(PG_FUNCTION_ARGS)
{
    HeapTuple   pl_tuple;
    Datum       ret;
    char       *source;
    bool        isnull;
    FmgrInfo   *arg_out_func;
    Form_pg_type type_struct;
    HeapTuple   type_tuple;
    Form_pg_proc pl_struct;
    volatile MemoryContext proc_cxt = NULL;
    Oid        *argtypes;
    char      **argnames;
    char       *argmodes;
    char       *proname;
    Form_pg_type pg_type_entry;
    Oid         result_typioparam;
    Oid         prorettype;
    FmgrInfo    result_in_func;
    int         numargs;
 
    /* Fetch the function's pg_proc entry. */
    pl_tuple = SearchSysCache1(PROCOID,
                               ObjectIdGetDatum(fcinfo->flinfo->fn_oid));
    if (!HeapTupleIsValid(pl_tuple))
        elog(ERROR, "cache lookup failed for function %u",
             fcinfo->flinfo->fn_oid);
 
    /*
     * Extract and print the source text of the function.  This can be used as
     * a base for the function validation and execution.
     */
    pl_struct = (Form_pg_proc) GETSTRUCT(pl_tuple);
    proname = pstrdup(NameStr(pl_struct->proname));
    ret = SysCacheGetAttr(PROCOID, pl_tuple, Anum_pg_proc_prosrc, &isnull);
    if (isnull)
        elog(ERROR, "could not find source text of function \"%s\"",
             proname);
    source = DatumGetCString(DirectFunctionCall1(textout, ret));
    ereport(NOTICE,
            (errmsg("source text of function \"%s\": %s",
                    proname, source)));
 
    /*
     * Allocate a context that will hold all the Postgres data for the
     * procedure.
     */
    proc_cxt = AllocSetContextCreate(TopMemoryContext,
                                     "PL/Sample function",
                                     ALLOCSET_SMALL_SIZES);
 
    arg_out_func = (FmgrInfo *) palloc0(fcinfo->nargs * sizeof(FmgrInfo));
    numargs = get_func_arg_info(pl_tuple, &argtypes, &argnames, &argmodes);
 
    /*
     * Iterate through all of the function arguments, printing each input
     * value.
     */
    for (int i = 0; i < numargs; i++)
    {
        Oid         argtype = pl_struct->proargtypes.values[i];
        char       *value;
 
        type_tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(argtype));
        if (!HeapTupleIsValid(type_tuple))
            elog(ERROR, "cache lookup failed for type %u", argtype);
 
        type_struct = (Form_pg_type) GETSTRUCT(type_tuple);
        fmgr_info_cxt(type_struct->typoutput, &(arg_out_func[i]), proc_cxt);
        ReleaseSysCache(type_tuple);
 
        value = OutputFunctionCall(&arg_out_func[i], fcinfo->args[i].value);
        ereport(NOTICE,
                (errmsg("argument: %d; name: %s; value: %s",
                        i, argnames[i], value)));
    }
 
    /* Type of the result */
    prorettype = pl_struct->prorettype;
    ReleaseSysCache(pl_tuple);
 
    /*
     * Get the required information for input conversion of the return value.
     *
     * If the function uses VOID as result, it is better to return NULL.
     * Anyway, let's be honest.  This is just a template, so there is not much
     * we can do here.  This returns NULL except if the result type is text,
     * where the result is the source text of the function.
     */
    if (prorettype != TEXTOID)
        PG_RETURN_NULL();
 
    type_tuple = SearchSysCache1(TYPEOID,
                                 ObjectIdGetDatum(prorettype));
    if (!HeapTupleIsValid(type_tuple))
        elog(ERROR, "cache lookup failed for type %u", prorettype);
    pg_type_entry = (Form_pg_type) GETSTRUCT(type_tuple);
    result_typioparam = getTypeIOParam(type_tuple);
 
    fmgr_info_cxt(pg_type_entry->typinput, &result_in_func, proc_cxt);
    ReleaseSysCache(type_tuple);
 
    ret = InputFunctionCall(&result_in_func, source, result_typioparam, -1);
    PG_RETURN_DATUM(ret);
}
 
/*
 * plsample_trigger_handler
 *
 * Function called by the call handler for trigger execution.
 */
static HeapTuple
plsample_trigger_handler(PG_FUNCTION_ARGS)
{
    TriggerData *trigdata = (TriggerData *) fcinfo->context;
    char       *string;
    volatile HeapTuple rettup;
    HeapTuple   pl_tuple;
    Datum       ret;
    char       *source;
    bool        isnull;
    Form_pg_proc pl_struct;
    char       *proname;
    int         rc PG_USED_FOR_ASSERTS_ONLY;
 
    /* Make sure this is being called from a trigger. */
    if (!CALLED_AS_TRIGGER(fcinfo))
        elog(ERROR, "not called by trigger manager");
 
    /* Connect to the SPI manager */
    if (SPI_connect() != SPI_OK_CONNECT)
        elog(ERROR, "could not connect to SPI manager");
 
    rc = SPI_register_trigger_data(trigdata);
    Assert(rc >= 0);
 
    /* Fetch the function's pg_proc entry. */
    pl_tuple = SearchSysCache1(PROCOID,
                               ObjectIdGetDatum(fcinfo->flinfo->fn_oid));
    if (!HeapTupleIsValid(pl_tuple))
        elog(ERROR, "cache lookup failed for function %u",
             fcinfo->flinfo->fn_oid);
 
    /*
     * Code Retrieval
     *
     * Extract and print the source text of the function.  This can be used as
     * a base for the function validation and execution.
     */
    pl_struct = (Form_pg_proc) GETSTRUCT(pl_tuple);
    proname = pstrdup(NameStr(pl_struct->proname));
    ret = SysCacheGetAttr(PROCOID, pl_tuple, Anum_pg_proc_prosrc, &isnull);
    if (isnull)
        elog(ERROR, "could not find source text of function \"%s\"",
             proname);
    source = DatumGetCString(DirectFunctionCall1(textout, ret));
    ereport(NOTICE,
            (errmsg("source text of function \"%s\": %s",
                    proname, source)));
 
    /*
     * We're done with the pg_proc tuple, so release it.  (Note that the
     * "proname" and "source" strings are now standalone copies.)
     */
    ReleaseSysCache(pl_tuple);
 
    /*
     * Code Augmentation
     *
     * The source text may be augmented here, such as by wrapping it as the
     * body of a function in the target language, prefixing a parameter list
     * with names like TD_name, TD_relid, TD_table_name, TD_table_schema,
     * TD_event, TD_when, TD_level, TD_NEW, TD_OLD, and args, using whatever
     * types in the target language are convenient. The augmented text can be
     * cached in a longer-lived memory context, or, if the target language
     * uses a compilation step, that can be done here, caching the result of
     * the compilation.
     */
 
    /*
     * Code Execution
     *
     * Here the function (the possibly-augmented source text, or the result of
     * compilation if the target language uses such a step) should be
     * executed, after binding values from the TriggerData struct to the
     * appropriate parameters.
     *
     * In this example we just print a lot of info via ereport.
     */
 
    PG_TRY();
    {
        ereport(NOTICE,
                (errmsg("trigger name: %s", trigdata->tg_trigger->tgname)));
        string = SPI_getrelname(trigdata->tg_relation);
        ereport(NOTICE, (errmsg("trigger relation: %s", string)));
 
        string = SPI_getnspname(trigdata->tg_relation);
        ereport(NOTICE, (errmsg("trigger relation schema: %s", string)));
 
        /* Example handling of different trigger aspects. */
 
        if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
        {
            ereport(NOTICE, (errmsg("triggered by INSERT")));
            rettup = trigdata->tg_trigtuple;
        }
        else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
        {
            ereport(NOTICE, (errmsg("triggered by DELETE")));
            rettup = trigdata->tg_trigtuple;
        }
        else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
        {
            ereport(NOTICE, (errmsg("triggered by UPDATE")));
            rettup = trigdata->tg_trigtuple;
        }
        else if (TRIGGER_FIRED_BY_TRUNCATE(trigdata->tg_event))
        {
            ereport(NOTICE, (errmsg("triggered by TRUNCATE")));
            rettup = trigdata->tg_trigtuple;
        }
        else
            elog(ERROR, "unrecognized event: %u", trigdata->tg_event);
 
        if (TRIGGER_FIRED_BEFORE(trigdata->tg_event))
            ereport(NOTICE, (errmsg("triggered BEFORE")));
        else if (TRIGGER_FIRED_AFTER(trigdata->tg_event))
            ereport(NOTICE, (errmsg("triggered AFTER")));
        else if (TRIGGER_FIRED_INSTEAD(trigdata->tg_event))
            ereport(NOTICE, (errmsg("triggered INSTEAD OF")));
        else
            elog(ERROR, "unrecognized when: %u", trigdata->tg_event);
 
        if (TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
            ereport(NOTICE, (errmsg("triggered per row")));
        else if (TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event))
            ereport(NOTICE, (errmsg("triggered per statement")));
        else
            elog(ERROR, "unrecognized level: %u", trigdata->tg_event);
 
        /*
         * Iterate through all of the trigger arguments, printing each input
         * value.
         */
        for (int i = 0; i < trigdata->tg_trigger->tgnargs; i++)
            ereport(NOTICE,
                    (errmsg("trigger arg[%i]: %s", i,
                            trigdata->tg_trigger->tgargs[i])));
    }
    PG_CATCH();
    {
        /* Error cleanup code would go here */
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    if (SPI_finish() != SPI_OK_FINISH)
        elog(ERROR, "SPI_finish() failed");
 
    return rettup;
}