plpy_procedure.h File Reference

#include "plpy_typeio.h"
#include "utils/funccache.h"

Include dependency graph for plpy_procedure.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PLySavedArgs
struct	PLySRFState
struct	PLyProcedure
struct	PLyProcedureCache

Typedefs
typedef enum PLyTrigType	PLyTrigType
typedef struct PLySavedArgs	PLySavedArgs
typedef struct PLySRFState	PLySRFState
typedef struct PLyProcedure	PLyProcedure
typedef struct PLyProcedureCache	PLyProcedureCache

Enumerations
enum	PLyTrigType { PLPY_TRIGGER , PLPY_EVENT_TRIGGER , PLPY_NOT_TRIGGER }

Functions
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)

Typedef Documentation

PLyProcedure

typedef struct PLyProcedure PLyProcedure

PLyProcedureCache

typedef struct PLyProcedureCache PLyProcedureCache

PLySavedArgs

typedef struct PLySavedArgs PLySavedArgs

PLySRFState

typedef struct PLySRFState PLySRFState

PLyTrigType

typedef enum PLyTrigType PLyTrigType

Enumeration Type Documentation

PLyTrigType

enum PLyTrigType

Enumerator
PLPY_TRIGGER
PLPY_EVENT_TRIGGER
PLPY_NOT_TRIGGER

Definition at line 15 of file plpy_procedure.h.

{
    PLPY_TRIGGER,
    PLPY_EVENT_TRIGGER,
    PLPY_NOT_TRIGGER,
} PLyTrigType;

Function Documentation

PLy_procedure_compile()

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

extern

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_delete()

void PLy_procedure_delete ( PLyProcedure *  proc )

extern

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  )

extern

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_name()

char * PLy_procedure_name ( PLyProcedure *  proc )

extern

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().