plpy_procedure.h File Reference

#include "plpy_typeio.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	PLyProcedure
struct	PLyProcedureKey
struct	PLyProcedureEntry

Typedefs
typedef enum PLyTrigType	PLyTrigType
typedef struct PLySavedArgs	PLySavedArgs
typedef struct PLyProcedure	PLyProcedure
typedef struct PLyProcedureKey	PLyProcedureKey
typedef struct PLyProcedureEntry	PLyProcedureEntry

Enumerations
enum	PLyTrigType { PLPY_TRIGGER , PLPY_EVENT_TRIGGER , PLPY_NOT_TRIGGER }

Functions
void	init_procedure_caches (void)
char *	PLy_procedure_name (PLyProcedure *proc)
PLyProcedure *	PLy_procedure_get (Oid fn_oid, Oid fn_rel, PLyTrigType is_trigger)
void	PLy_procedure_compile (PLyProcedure *proc, const char *src)
void	PLy_procedure_delete (PLyProcedure *proc)

Typedef Documentation

PLyProcedure

typedef struct PLyProcedure PLyProcedure

PLyProcedureEntry

typedef struct PLyProcedureEntry PLyProcedureEntry

PLyProcedureKey

typedef struct PLyProcedureKey PLyProcedureKey

PLySavedArgs

typedef struct PLySavedArgs PLySavedArgs

PLyTrigType

typedef enum PLyTrigType PLyTrigType

Enumeration Type Documentation

PLyTrigType

enum PLyTrigType

Enumerator
PLPY_TRIGGER
PLPY_EVENT_TRIGGER
PLPY_NOT_TRIGGER

Definition at line 17 of file plpy_procedure.h.

{
    PLPY_TRIGGER,
    PLPY_EVENT_TRIGGER,
    PLPY_NOT_TRIGGER,
} PLyTrigType;

Function Documentation

init_procedure_caches()

void init_procedure_caches ( void  )

extern

Definition at line 30 of file plpy_procedure.c.

{
    HASHCTL     hash_ctl;
 
    hash_ctl.keysize = sizeof(PLyProcedureKey);
    hash_ctl.entrysize = sizeof(PLyProcedureEntry);
    PLy_procedure_cache = hash_create("PL/Python procedures", 32, &hash_ctl,
                                      HASH_ELEM | HASH_BLOBS);
}

References fb(), HASH_BLOBS, hash_create(), HASH_ELEM, HASHCTL::keysize, and PLy_procedure_cache.

Referenced by _PG_init().

PLy_procedure_compile()

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

extern

Definition at line 365 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 419 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_procedure_create(), and PLy_procedure_get().

PLy_procedure_get()

PLyProcedure * PLy_procedure_get ( Oid  fn_oid, Oid  fn_rel, PLyTrigType  is_trigger  )

extern

Definition at line 71 of file plpy_procedure.c.

{
    bool        use_cache;
    HeapTuple   procTup;
    PLyProcedureKey key;
    PLyProcedureEntry *volatile entry = NULL;
    PLyProcedure *volatile proc = NULL;
    bool        found = false;
 
    if (is_trigger == PLPY_TRIGGER && fn_rel == InvalidOid)
        use_cache = false;
    else
        use_cache = true;
 
    procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(fn_oid));
    if (!HeapTupleIsValid(procTup))
        elog(ERROR, "cache lookup failed for function %u", fn_oid);
 
    /*
     * Look for the function in the cache, unless we don't have the necessary
     * information (e.g. during validation). In that case we just don't cache
     * anything.
     */
    if (use_cache)
    {
        key.fn_oid = fn_oid;
        key.fn_rel = fn_rel;
        entry = hash_search(PLy_procedure_cache, &key, HASH_ENTER, &found);
        proc = entry->proc;
    }
 
    PG_TRY();
    {
        if (!found)
        {
            /* Haven't found it, create a new procedure */
            proc = PLy_procedure_create(procTup, fn_oid, is_trigger);
            if (use_cache)
                entry->proc = proc;
            else
            {
                /* Delete the proc, otherwise it's a memory leak */
                PLy_procedure_delete(proc);
                proc = NULL;
            }
        }
        else if (!PLy_procedure_valid(proc, procTup))
        {
            /* Found it, but it's invalid, free and reuse the cache entry */
            entry->proc = NULL;
            if (proc)
                PLy_procedure_delete(proc);
            proc = PLy_procedure_create(procTup, fn_oid, is_trigger);
            entry->proc = proc;
        }
        /* Found it and it's valid, it's fine to use it */
    }
    PG_CATCH();
    {
        /* Do not leave an uninitialized entry in the cache */
        if (use_cache)
            hash_search(PLy_procedure_cache, &key, HASH_REMOVE, NULL);
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    ReleaseSysCache(procTup);
 
    return proc;
}

References elog, ERROR, fb(), HASH_ENTER, HASH_REMOVE, hash_search(), HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PLPY_TRIGGER, PLy_procedure_cache, PLy_procedure_create(), PLy_procedure_delete(), PLy_procedure_valid(), PLyProcedureEntry::proc, ReleaseSysCache(), and SearchSysCache1().

Referenced by plpython3_call_handler(), and plpython3_validator().

PLy_procedure_name()

char * PLy_procedure_name ( PLyProcedure *  proc )

extern

Definition at line 46 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().