plpy_procedure.c File Reference

#include "postgres.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "commands/event_trigger.h"
#include "commands/trigger.h"
#include "funcapi.h"
#include "plpy_elog.h"
#include "plpy_exec.h"
#include "plpy_main.h"
#include "plpy_procedure.h"
#include "plpy_util.h"
#include "utils/builtins.h"
#include "utils/funccache.h"
#include "utils/syscache.h"

Include dependency graph for plpy_procedure.c:

Go to the source code of this file.

Functions
static void	PLy_procedure_create (PLyProcedure *proc, HeapTuple procTup, Oid fn_oid, PLyTrigType is_trigger)
static char *	PLy_procedure_munge_source (const char *name, const char *src)
static void	PLy_compile_callback (FunctionCallInfo fcinfo, HeapTuple procTup, const CachedFunctionHashKey *hashkey, CachedFunction *cfunc, bool forValidator)
static void	PLy_delete_callback (CachedFunction *cfunc)
static void	RemovePLyProcedureCache (void *arg)
char *	PLy_procedure_name (PLyProcedure *proc)
PLyProcedureCache *	PLy_procedure_get (FunctionCallInfo fcinfo, bool forValidator)
void	PLy_procedure_compile (PLyProcedure *proc, const char *src)
void	PLy_procedure_delete (PLyProcedure *proc)

Function Documentation

PLy_compile_callback()

static void PLy_compile_callback ( FunctionCallInfo  fcinfo, HeapTuple  procTup, const CachedFunctionHashKey *  hashkey, CachedFunction *  cfunc, bool  forValidator  )

static

Definition at line 478 of file plpy_procedure.c.

{
    PLyProcedure *proc = (PLyProcedure *) cfunc;
    Oid         fn_oid = fcinfo->flinfo->fn_oid;
    PLyTrigType is_trigger;
 
    /*
     * Derive the trigger type from the call context, matching what
     * plpython3_call_handler dispatches on.
     */
    if (CALLED_AS_TRIGGER(fcinfo))
        is_trigger = PLPY_TRIGGER;
    else if (CALLED_AS_EVENT_TRIGGER(fcinfo))
        is_trigger = PLPY_EVENT_TRIGGER;
    else
        is_trigger = PLPY_NOT_TRIGGER;
 
    PLy_procedure_create(proc, procTup, fn_oid, is_trigger);
}

References CALLED_AS_EVENT_TRIGGER, CALLED_AS_TRIGGER, fb(), FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_oid, PLPY_EVENT_TRIGGER, PLPY_NOT_TRIGGER, PLPY_TRIGGER, and PLy_procedure_create().

Referenced by PLy_procedure_get().

PLy_delete_callback()

static void PLy_delete_callback ( CachedFunction *  cfunc )

static

Definition at line 510 of file plpy_procedure.c.

{
    PLyProcedure *proc = (PLyProcedure *) cfunc;
 
    Assert(proc->cfunc.use_count == 0);
    Assert(proc->calldepth == 0);
 
    PLy_procedure_delete(proc);
}

References Assert, PLyProcedure::calldepth, PLyProcedure::cfunc, PLy_procedure_delete(), and CachedFunction::use_count.

Referenced by PLy_procedure_get().

PLy_procedure_compile()

void PLy_procedure_compile	(	PLyProcedure *	proc,
		const char *	src
	)

Definition at line 362 of file plpy_procedure.c.

{
    PyObject   *crv = NULL;
    char       *msrc;
    PyObject   *code0;
 
    proc->globals = PyDict_Copy(PLy_interp_globals);
 
    /*
     * SD is private preserved data between calls. GD is global data shared by
     * all functions
     */
    proc->statics = PyDict_New();
    if (!proc->statics)
        PLy_elog(ERROR, NULL);
    PyDict_SetItemString(proc->globals, "SD", proc->statics);
 
    /*
     * insert the function code into the interpreter
     */
    msrc = PLy_procedure_munge_source(proc->pyname, src);
    /* Save the mangled source for later inclusion in tracebacks */
    proc->src = MemoryContextStrdup(proc->mcxt, msrc);
    code0 = Py_CompileString(msrc, "<string>", Py_file_input);
    if (code0)
        crv = PyEval_EvalCode(code0, proc->globals, NULL);
    pfree(msrc);
 
    if (crv != NULL)
    {
        int         clen;
        char        call[NAMEDATALEN + 256];
 
        Py_DECREF(crv);
 
        /*
         * compile a call to the function
         */
        clen = snprintf(call, sizeof(call), "%s()", proc->pyname);
        if (clen < 0 || clen >= sizeof(call))
            elog(ERROR, "string would overflow buffer");
        proc->code = Py_CompileString(call, "<string>", Py_eval_input);
        if (proc->code != NULL)
            return;
    }
 
    if (proc->proname)
        PLy_elog(ERROR, "could not compile PL/Python function \"%s\"",
                 proc->proname);
    else
        PLy_elog(ERROR, "could not compile anonymous PL/Python code block");
}

References PLyProcedure::code, elog, ERROR, fb(), PLyProcedure::globals, PLyProcedure::mcxt, MemoryContextStrdup(), NAMEDATALEN, pfree(), PLy_elog, PLy_interp_globals, PLy_procedure_munge_source(), PLyProcedure::proname, PLyProcedure::pyname, snprintf, PLyProcedure::src, and PLyProcedure::statics.

Referenced by plpython3_inline_handler(), and PLy_procedure_create().

PLy_procedure_create()

static void PLy_procedure_create ( PLyProcedure *  proc, HeapTuple  procTup, Oid  fn_oid, PLyTrigType  is_trigger  )

static

Definition at line 145 of file plpy_procedure.c.

{
    char        procName[NAMEDATALEN + 256];
    Form_pg_proc procStruct;
    MemoryContext cxt;
    MemoryContext oldcxt;
    int         rv;
    char       *ptr;
 
    procStruct = (Form_pg_proc) GETSTRUCT(procTup);
    rv = snprintf(procName, sizeof(procName),
                  "__plpython_procedure_%s_%u",
                  NameStr(procStruct->proname),
                  fn_oid);
    if (rv >= sizeof(procName) || rv < 0)
        elog(ERROR, "procedure name would overrun buffer");
 
    /* Replace any not-legal-in-Python-names characters with '_' */
    for (ptr = procName; *ptr; ptr++)
    {
        if (!((*ptr >= 'A' && *ptr <= 'Z') ||
              (*ptr >= 'a' && *ptr <= 'z') ||
              (*ptr >= '0' && *ptr <= '9')))
            *ptr = '_';
    }
 
    /* Create long-lived context that all procedure info will live in */
    cxt = AllocSetContextCreate(TopMemoryContext,
                                "PL/Python function",
                                ALLOCSET_DEFAULT_SIZES);
 
    oldcxt = MemoryContextSwitchTo(cxt);
 
    proc->mcxt = cxt;
 
    PG_TRY();
    {
        Datum       protrftypes_datum;
        Datum       prosrcdatum;
        bool        isnull;
        char       *procSource;
        int         i;
 
        proc->proname = pstrdup(NameStr(procStruct->proname));
        MemoryContextSetIdentifier(cxt, proc->proname);
        proc->pyname = pstrdup(procName);
        proc->fn_readonly = (procStruct->provolatile != PROVOLATILE_VOLATILE);
        proc->is_setof = procStruct->proretset;
        proc->is_procedure = (procStruct->prokind == PROKIND_PROCEDURE);
        proc->is_trigger = is_trigger;
        proc->src = NULL;
        proc->argnames = NULL;
        proc->args = NULL;
        proc->nargs = 0;
        proc->langid = procStruct->prolang;
        protrftypes_datum = SysCacheGetAttr(PROCOID, procTup,
                                            Anum_pg_proc_protrftypes,
                                            &isnull);
        proc->trftypes = isnull ? NIL : oid_array_to_list(protrftypes_datum);
        proc->code = NULL;
        proc->statics = NULL;
        proc->globals = NULL;
        proc->calldepth = 0;
        proc->argstack = NULL;
 
        /*
         * get information required for output conversion of the return value,
         * but only if this isn't a trigger.
         */
        if (is_trigger == PLPY_NOT_TRIGGER)
        {
            Oid         rettype = procStruct->prorettype;
            HeapTuple   rvTypeTup;
            Form_pg_type rvTypeStruct;
 
            rvTypeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(rettype));
            if (!HeapTupleIsValid(rvTypeTup))
                elog(ERROR, "cache lookup failed for type %u", rettype);
            rvTypeStruct = (Form_pg_type) GETSTRUCT(rvTypeTup);
 
            /* Disallow pseudotype result, except for void or record */
            if (rvTypeStruct->typtype == TYPTYPE_PSEUDO)
            {
                if (rettype == VOIDOID ||
                    rettype == RECORDOID)
                     /* okay */ ;
                else if (rettype == TRIGGEROID || rettype == EVENT_TRIGGEROID)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("trigger functions can only be called as triggers")));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("PL/Python functions cannot return type %s",
                                    format_type_be(rettype))));
            }
 
            /* set up output function for procedure result */
            PLy_output_setup_func(&proc->result, proc->mcxt,
                                  rettype, -1, proc);
 
            ReleaseSysCache(rvTypeTup);
        }
        else
        {
            /*
             * In a trigger function, we use proc->result and proc->result_in
             * for converting tuples, but we don't yet have enough info to set
             * them up.  PLy_exec_trigger will deal with it.
             */
            proc->result.typoid = InvalidOid;
            proc->result_in.typoid = InvalidOid;
        }
 
        /*
         * Now get information required for input conversion of the
         * procedure's arguments.  Note that we ignore output arguments here.
         * If the function returns record, those I/O functions will be set up
         * when the function is first called.
         */
        if (procStruct->pronargs)
        {
            Oid        *types;
            char      **names,
                       *modes;
            int         pos,
                        total;
 
            /* extract argument type info from the pg_proc tuple */
            total = get_func_arg_info(procTup, &types, &names, &modes);
 
            /* count number of in+inout args into proc->nargs */
            if (modes == NULL)
                proc->nargs = total;
            else
            {
                /* proc->nargs was initialized to 0 above */
                for (i = 0; i < total; i++)
                {
                    if (modes[i] != PROARGMODE_OUT &&
                        modes[i] != PROARGMODE_TABLE)
                        (proc->nargs)++;
                }
            }
 
            /* Allocate arrays for per-input-argument data */
            proc->argnames = (char **) palloc0_array(char *, proc->nargs);
            proc->args = (PLyDatumToOb *) palloc0_array(PLyDatumToOb, proc->nargs);
 
            for (i = pos = 0; i < total; i++)
            {
                HeapTuple   argTypeTup;
                Form_pg_type argTypeStruct;
 
                if (modes &&
                    (modes[i] == PROARGMODE_OUT ||
                     modes[i] == PROARGMODE_TABLE))
                    continue;   /* skip OUT arguments */
 
                Assert(types[i] == procStruct->proargtypes.values[pos]);
 
                argTypeTup = SearchSysCache1(TYPEOID,
                                             ObjectIdGetDatum(types[i]));
                if (!HeapTupleIsValid(argTypeTup))
                    elog(ERROR, "cache lookup failed for type %u", types[i]);
                argTypeStruct = (Form_pg_type) GETSTRUCT(argTypeTup);
 
                /* disallow pseudotype arguments */
                if (argTypeStruct->typtype == TYPTYPE_PSEUDO)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("PL/Python functions cannot accept type %s",
                                    format_type_be(types[i]))));
 
                /* set up I/O function info */
                PLy_input_setup_func(&proc->args[pos], proc->mcxt,
                                     types[i], -1,  /* typmod not known */
                                     proc);
 
                /* get argument name */
                proc->argnames[pos] = names ? pstrdup(names[i]) : NULL;
 
                ReleaseSysCache(argTypeTup);
 
                pos++;
            }
        }
 
        /*
         * get the text of the function.
         */
        prosrcdatum = SysCacheGetAttrNotNull(PROCOID, procTup,
                                             Anum_pg_proc_prosrc);
        procSource = TextDatumGetCString(prosrcdatum);
 
        PLy_procedure_compile(proc, procSource);
 
        pfree(procSource);
    }
    PG_CATCH();
    {
        MemoryContextSwitchTo(oldcxt);
        PLy_procedure_delete(proc);
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    MemoryContextSwitchTo(oldcxt);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, PLyProcedure::argnames, PLyProcedure::args, PLyProcedure::argstack, Assert, PLyProcedure::calldepth, PLyProcedure::code, elog, ereport, errcode(), errmsg, ERROR, fb(), PLyProcedure::fn_readonly, Form_pg_proc, Form_pg_type, format_type_be(), get_func_arg_info(), GETSTRUCT(), PLyProcedure::globals, HeapTupleIsValid, i, InvalidOid, PLyProcedure::is_procedure, PLyProcedure::is_setof, PLyProcedure::is_trigger, PLyProcedure::langid, PLyProcedure::mcxt, MemoryContextSetIdentifier(), MemoryContextSwitchTo(), NAMEDATALEN, NameStr, PLyProcedure::nargs, NIL, ObjectIdGetDatum(), oid_array_to_list(), palloc0_array, pfree(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PLPY_NOT_TRIGGER, PLy_input_setup_func(), PLy_output_setup_func(), PLy_procedure_compile(), PLy_procedure_delete(), PLyProcedure::proname, pstrdup(), PLyProcedure::pyname, ReleaseSysCache(), PLyProcedure::result, PLyProcedure::result_in, SearchSysCache1(), snprintf, PLyProcedure::src, PLyProcedure::statics, SysCacheGetAttr(), SysCacheGetAttrNotNull(), TextDatumGetCString, TopMemoryContext, PLyProcedure::trftypes, types, PLyDatumToOb::typoid, and PLyObToDatum::typoid.

Referenced by PLy_compile_callback().

PLy_procedure_delete()

void PLy_procedure_delete

(

PLyProcedure *

proc

)

Definition at line 416 of file plpy_procedure.c.

{
    Py_XDECREF(proc->code);
    Py_XDECREF(proc->statics);
    Py_XDECREF(proc->globals);
    MemoryContextDelete(proc->mcxt);
}

References PLyProcedure::code, fb(), PLyProcedure::globals, PLyProcedure::mcxt, MemoryContextDelete(), and PLyProcedure::statics.

Referenced by plpython3_inline_handler(), PLy_delete_callback(), and PLy_procedure_create().

PLy_procedure_get()

PLyProcedureCache * PLy_procedure_get	(	FunctionCallInfo	fcinfo,
		bool	forValidator
	)

Definition at line 62 of file plpy_procedure.c.

{
    FmgrInfo   *finfo = fcinfo->flinfo;
    PLyProcedureCache *pcache;
    PLyProcedure *proc;
 
    /*
     * If this is the first execution for this FmgrInfo, set up a cache struct
     * (initially containing null pointers).  The cache must live as long as
     * the FmgrInfo, so it goes in fn_mcxt.  Also set up a memory context
     * callback that will be invoked when fn_mcxt is reset/deleted.
     */
    pcache = finfo->fn_extra;
    if (pcache == NULL)
    {
        pcache = (PLyProcedureCache *)
            MemoryContextAllocZero(finfo->fn_mcxt, sizeof(PLyProcedureCache));
 
        pcache->fcontext = finfo->fn_mcxt;
        pcache->mcb.func = RemovePLyProcedureCache;
        pcache->mcb.arg = pcache;
 
        MemoryContextRegisterResetCallback(finfo->fn_mcxt, &pcache->mcb);
 
        finfo->fn_extra = pcache;
    }
 
    /*
     * If we are resuming execution of a set-returning function, just keep
     * using the same cache.  We do not ask funccache.c to re-validate the
     * PLyProcedure: we want to run to completion using the function's initial
     * definition.
     *
     * A live iterator (srfstate->iter != NULL) reliably means a genuine
     * resume: when an iteration ends for any reason, srfstate->iter is reset
     * to NULL (see comments for PLy_function_cleanup_srfstate).
     */
    if (pcache->srfstate != NULL && pcache->srfstate->iter != NULL)
    {
        Assert(pcache->proc != NULL);
        return pcache;
    }
 
    /*
     * Look up, or re-validate, the long-lived hash entry.  Like SQL-language
     * functions, make the hash key depend on the result of
     * get_call_result_type() when that's composite, so that we can safely
     * assume that we'll build a new hash entry if the composite rowtype
     * changes.
     */
    proc = (PLyProcedure *)
        cached_function_compile(fcinfo,
                                (CachedFunction *) pcache->proc,
                                PLy_compile_callback,
                                PLy_delete_callback,
                                sizeof(PLyProcedure),
                                true,
                                forValidator);
 
    /*
     * Install the hash pointer in the PLyProcedureCache, and increment its
     * use count to reflect that.  If cached_function_compile gave us back a
     * different hash entry than we were using before, we must decrement that
     * one's use count.
     */
    if (proc != pcache->proc)
    {
        if (pcache->proc != NULL)
        {
            Assert(pcache->proc->cfunc.use_count > 0);
            pcache->proc->cfunc.use_count--;
        }
        pcache->proc = proc;
        proc->cfunc.use_count++;
    }
 
    return pcache;
}

References Assert, cached_function_compile(), PLyProcedure::cfunc, fb(), FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, MemoryContextAllocZero(), MemoryContextRegisterResetCallback(), PLy_compile_callback(), PLy_delete_callback(), RemovePLyProcedureCache(), and CachedFunction::use_count.

Referenced by plpython3_call_handler(), and plpython3_validator().

PLy_procedure_munge_source()

static char * PLy_procedure_munge_source ( const char *  name, const char *  src  )

static

Definition at line 425 of file plpy_procedure.c.

{
    char       *mrc,
               *mp;
    const char *sp;
    size_t      mlen;
    int         plen;
 
    /*
     * room for function source and the def statement
     */
    mlen = (strlen(src) * 2) + strlen(name) + 16;
 
    mrc = palloc(mlen);
    plen = snprintf(mrc, mlen, "def %s():\n\t", name);
    Assert(plen >= 0 && plen < mlen);
 
    sp = src;
    mp = mrc + plen;
 
    while (*sp != '\0')
    {
        if (*sp == '\r' && *(sp + 1) == '\n')
            sp++;
 
        if (*sp == '\n' || *sp == '\r')
        {
            *mp++ = '\n';
            *mp++ = '\t';
            sp++;
        }
        else
            *mp++ = *sp++;
    }
    *mp++ = '\n';
    *mp++ = '\n';
    *mp = '\0';
 
    if (mp > (mrc + mlen))
        elog(FATAL, "buffer overrun in PLy_procedure_munge_source");
 
    return mrc;
}

References Assert, elog, FATAL, fb(), name, palloc(), and snprintf.

Referenced by PLy_procedure_compile().

PLy_procedure_name()

char * PLy_procedure_name

(

PLyProcedure *

proc

)

Definition at line 43 of file plpy_procedure.c.

{
    if (proc == NULL)
        return "<unknown procedure>";
    return proc->proname;
}

References fb(), and PLyProcedure::proname.

Referenced by plpython_error_callback(), and PLy_traceback().

RemovePLyProcedureCache()

static void RemovePLyProcedureCache ( void *  arg )

static

Definition at line 536 of file plpy_procedure.c.

{
    PLyProcedureCache *pcache = (PLyProcedureCache *) arg;
 
    /* Release any Python state left behind by an interrupted SRF */
    PLy_function_cleanup_srfstate(pcache);
 
    /* Release reference count on PLyProcedure */
    if (pcache->proc != NULL)
    {
        Assert(pcache->proc->cfunc.use_count > 0);
        pcache->proc->cfunc.use_count--;
        pcache->proc = NULL;
    }
 
    /* We needn't free the pcache object itself, context cleanup does that */
}

References arg, Assert, fb(), and PLy_function_cleanup_srfstate().

Referenced by PLy_procedure_get().