plpy_main.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "commands/trigger.h"
#include "executor/spi.h"
#include "miscadmin.h"
#include "plpy_elog.h"
#include "plpy_exec.h"
#include "plpy_main.h"
#include "plpy_plpymodule.h"
#include "plpy_procedure.h"
#include "plpy_subxactobject.h"
#include "plpython.h"
#include "utils/guc.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for plpy_main.c:

Go to the source code of this file.

Functions
	PG_FUNCTION_INFO_V1 (plpython3_validator)
	PG_FUNCTION_INFO_V1 (plpython3_call_handler)
	PG_FUNCTION_INFO_V1 (plpython3_inline_handler)
static bool	PLy_procedure_is_trigger (Form_pg_proc procStruct)
static void	plpython_error_callback (void *arg)
static void	plpython_inline_error_callback (void *arg)
static void	PLy_init_interp (void)
static PLyExecutionContext *	PLy_push_execution_context (bool atomic_context)
static void	PLy_pop_execution_context (void)
void	_PG_init (void)
static void	PLy_initialize (void)
Datum	plpython3_validator (PG_FUNCTION_ARGS)
Datum	plpython3_call_handler (PG_FUNCTION_ARGS)
Datum	plpython3_inline_handler (PG_FUNCTION_ARGS)
PLyExecutionContext *	PLy_current_execution_context (void)
MemoryContext	PLy_get_scratch_context (PLyExecutionContext *context)

Variables
	PG_MODULE_MAGIC
static int *	plpython_version_bitmask_ptr = NULL
static int	plpython_version_bitmask = 0
PyObject *	PLy_interp_globals = NULL
static PLyExecutionContext *	PLy_execution_contexts = NULL

Function Documentation

_PG_init()

void _PG_init

(

void

)

Definition at line 58 of file plpy_main.c.

{
    int       **bitmask_ptr;
 
    /*
     * Set up a shared bitmask variable telling which Python version(s) are
     * loaded into this process's address space.  If there's more than one, we
     * cannot call into libpython for fear of causing crashes.  But postpone
     * the actual failure for later, so that operations like pg_restore can
     * load more than one plpython library so long as they don't try to do
     * anything much with the language.
     *
     * While we only support Python 3 these days, somebody might create an
     * out-of-tree version adding back support for Python 2. Conflicts with
     * such an extension should be detected.
     */
    bitmask_ptr = (int **) find_rendezvous_variable("plpython_version_bitmask");
    if (!(*bitmask_ptr))        /* am I the first? */
        *bitmask_ptr = &plpython_version_bitmask;
    /* Retain pointer to the agreed-on shared variable ... */
    plpython_version_bitmask_ptr = *bitmask_ptr;
    /* ... and announce my presence */
    *plpython_version_bitmask_ptr |= (1 << PY_MAJOR_VERSION);
 
    /*
     * This should be safe even in the presence of conflicting plpythons, and
     * it's necessary to do it before possibly throwing a conflict error, or
     * the error message won't get localized.
     */
    pg_bindtextdomain(TEXTDOMAIN);
}

References find_rendezvous_variable(), pg_bindtextdomain(), plpython_version_bitmask, plpython_version_bitmask_ptr, and TEXTDOMAIN.

PG_FUNCTION_INFO_V1() [1/3]

PG_FUNCTION_INFO_V1

(

plpython3_call_handler

)

PG_FUNCTION_INFO_V1() [2/3]

PG_FUNCTION_INFO_V1

(

plpython3_inline_handler

)

PG_FUNCTION_INFO_V1() [3/3]

PG_FUNCTION_INFO_V1

(

plpython3_validator

)

plpython3_call_handler()

Datum plpython3_call_handler

(

PG_FUNCTION_ARGS

)

Definition at line 191 of file plpy_main.c.

{
    bool        nonatomic;
    Datum       retval;
    PLyExecutionContext *exec_ctx;
    ErrorContextCallback plerrcontext;
 
    PLy_initialize();
 
    nonatomic = fcinfo->context &&
        IsA(fcinfo->context, CallContext) &&
        !castNode(CallContext, fcinfo->context)->atomic;
 
    /* Note: SPI_finish() happens in plpy_exec.c, which is dubious design */
    if (SPI_connect_ext(nonatomic ? SPI_OPT_NONATOMIC : 0) != SPI_OK_CONNECT)
        elog(ERROR, "SPI_connect failed");
 
    /*
     * Push execution context onto stack.  It is important that this get
     * popped again, so avoid putting anything that could throw error between
     * here and the PG_TRY.
     */
    exec_ctx = PLy_push_execution_context(!nonatomic);
 
    PG_TRY();
    {
        Oid         funcoid = fcinfo->flinfo->fn_oid;
        PLyProcedure *proc;
 
        /*
         * Setup error traceback support for ereport().  Note that the PG_TRY
         * structure pops this for us again at exit, so we needn't do that
         * explicitly, nor do we risk the callback getting called after we've
         * destroyed the exec_ctx.
         */
        plerrcontext.callback = plpython_error_callback;
        plerrcontext.arg = exec_ctx;
        plerrcontext.previous = error_context_stack;
        error_context_stack = &plerrcontext;
 
        if (CALLED_AS_TRIGGER(fcinfo))
        {
            Relation    tgrel = ((TriggerData *) fcinfo->context)->tg_relation;
            HeapTuple   trv;
 
            proc = PLy_procedure_get(funcoid, RelationGetRelid(tgrel), true);
            exec_ctx->curr_proc = proc;
            trv = PLy_exec_trigger(fcinfo, proc);
            retval = PointerGetDatum(trv);
        }
        else
        {
            proc = PLy_procedure_get(funcoid, InvalidOid, false);
            exec_ctx->curr_proc = proc;
            retval = PLy_exec_function(fcinfo, proc);
        }
    }
    PG_CATCH();
    {
        PLy_pop_execution_context();
        PyErr_Clear();
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    /* Destroy the execution context */
    PLy_pop_execution_context();
 
    return retval;
}

References ErrorContextCallback::arg, ErrorContextCallback::callback, CALLED_AS_TRIGGER, castNode, PLyExecutionContext::curr_proc, elog, ERROR, error_context_stack, InvalidOid, IsA, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, plpython_error_callback(), PLy_exec_function(), PLy_exec_trigger(), PLy_initialize(), PLy_pop_execution_context(), PLy_procedure_get(), PLy_push_execution_context(), PointerGetDatum(), ErrorContextCallback::previous, RelationGetRelid, SPI_connect_ext(), SPI_OK_CONNECT, and SPI_OPT_NONATOMIC.

plpython3_inline_handler()

Datum plpython3_inline_handler

(

PG_FUNCTION_ARGS

)

Definition at line 263 of file plpy_main.c.

{
    LOCAL_FCINFO(fake_fcinfo, 0);
    InlineCodeBlock *codeblock = (InlineCodeBlock *) DatumGetPointer(PG_GETARG_DATUM(0));
    FmgrInfo    flinfo;
    PLyProcedure proc;
    PLyExecutionContext *exec_ctx;
    ErrorContextCallback plerrcontext;
 
    PLy_initialize();
 
    /* Note: SPI_finish() happens in plpy_exec.c, which is dubious design */
    if (SPI_connect_ext(codeblock->atomic ? 0 : SPI_OPT_NONATOMIC) != SPI_OK_CONNECT)
        elog(ERROR, "SPI_connect failed");
 
    MemSet(fcinfo, 0, SizeForFunctionCallInfo(0));
    MemSet(&flinfo, 0, sizeof(flinfo));
    fake_fcinfo->flinfo = &flinfo;
    flinfo.fn_oid = InvalidOid;
    flinfo.fn_mcxt = CurrentMemoryContext;
 
    MemSet(&proc, 0, sizeof(PLyProcedure));
    proc.mcxt = AllocSetContextCreate(TopMemoryContext,
                                      "__plpython_inline_block",
                                      ALLOCSET_DEFAULT_SIZES);
    proc.pyname = MemoryContextStrdup(proc.mcxt, "__plpython_inline_block");
    proc.langid = codeblock->langOid;
 
    /*
     * This is currently sufficient to get PLy_exec_function to work, but
     * someday we might need to be honest and use PLy_output_setup_func.
     */
    proc.result.typoid = VOIDOID;
 
    /*
     * Push execution context onto stack.  It is important that this get
     * popped again, so avoid putting anything that could throw error between
     * here and the PG_TRY.
     */
    exec_ctx = PLy_push_execution_context(codeblock->atomic);
 
    PG_TRY();
    {
        /*
         * Setup error traceback support for ereport().
         * plpython_inline_error_callback doesn't currently need exec_ctx, but
         * for consistency with plpython3_call_handler we do it the same way.
         */
        plerrcontext.callback = plpython_inline_error_callback;
        plerrcontext.arg = exec_ctx;
        plerrcontext.previous = error_context_stack;
        error_context_stack = &plerrcontext;
 
        PLy_procedure_compile(&proc, codeblock->source_text);
        exec_ctx->curr_proc = &proc;
        PLy_exec_function(fake_fcinfo, &proc);
    }
    PG_CATCH();
    {
        PLy_pop_execution_context();
        PLy_procedure_delete(&proc);
        PyErr_Clear();
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    /* Destroy the execution context */
    PLy_pop_execution_context();
 
    /* Now clean up the transient procedure we made */
    PLy_procedure_delete(&proc);
 
    PG_RETURN_VOID();
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ErrorContextCallback::arg, InlineCodeBlock::atomic, ErrorContextCallback::callback, PLyExecutionContext::curr_proc, CurrentMemoryContext, DatumGetPointer(), elog, ERROR, error_context_stack, FmgrInfo::fn_mcxt, FmgrInfo::fn_oid, InvalidOid, PLyProcedure::langid, InlineCodeBlock::langOid, LOCAL_FCINFO, PLyProcedure::mcxt, MemoryContextStrdup(), MemSet, PG_CATCH, PG_END_TRY, PG_GETARG_DATUM, PG_RE_THROW, PG_RETURN_VOID, PG_TRY, plpython_inline_error_callback(), PLy_exec_function(), PLy_initialize(), PLy_pop_execution_context(), PLy_procedure_compile(), PLy_procedure_delete(), PLy_push_execution_context(), ErrorContextCallback::previous, PLyProcedure::pyname, PLyProcedure::result, SizeForFunctionCallInfo, InlineCodeBlock::source_text, SPI_connect_ext(), SPI_OK_CONNECT, SPI_OPT_NONATOMIC, TopMemoryContext, and PLyObToDatum::typoid.

plpython3_validator()

Datum plpython3_validator

(

PG_FUNCTION_ARGS

)

Definition at line 158 of file plpy_main.c.

{
    Oid         funcoid = PG_GETARG_OID(0);
    HeapTuple   tuple;
    Form_pg_proc procStruct;
    bool        is_trigger;
 
    if (!CheckFunctionValidatorAccess(fcinfo->flinfo->fn_oid, funcoid))
        PG_RETURN_VOID();
 
    if (!check_function_bodies)
        PG_RETURN_VOID();
 
    /* Do this only after making sure we need to do something */
    PLy_initialize();
 
    /* 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);
    procStruct = (Form_pg_proc) GETSTRUCT(tuple);
 
    is_trigger = PLy_procedure_is_trigger(procStruct);
 
    ReleaseSysCache(tuple);
 
    /* We can't validate triggers against any particular table ... */
    PLy_procedure_get(funcoid, InvalidOid, is_trigger);
 
    PG_RETURN_VOID();
}

References check_function_bodies, CheckFunctionValidatorAccess(), elog, ERROR, GETSTRUCT, HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_VOID, PLy_initialize(), PLy_procedure_get(), PLy_procedure_is_trigger(), ReleaseSysCache(), and SearchSysCache1().

plpython_error_callback()

static void plpython_error_callback ( void *  arg )

static

Definition at line 345 of file plpy_main.c.

{
    PLyExecutionContext *exec_ctx = (PLyExecutionContext *) arg;
 
    if (exec_ctx->curr_proc)
    {
        if (exec_ctx->curr_proc->is_procedure)
            errcontext("PL/Python procedure \"%s\"",
                       PLy_procedure_name(exec_ctx->curr_proc));
        else
            errcontext("PL/Python function \"%s\"",
                       PLy_procedure_name(exec_ctx->curr_proc));
    }
}

References arg, PLyExecutionContext::curr_proc, errcontext, PLyProcedure::is_procedure, and PLy_procedure_name().

Referenced by plpython3_call_handler().

plpython_inline_error_callback()

static void plpython_inline_error_callback ( void *  arg )

static

Definition at line 361 of file plpy_main.c.

{
    errcontext("PL/Python anonymous code block");
}

References errcontext.

Referenced by plpython3_inline_handler().

PLy_current_execution_context()

PLyExecutionContext* PLy_current_execution_context

(

void

)

Definition at line 367 of file plpy_main.c.

{
    if (PLy_execution_contexts == NULL)
        elog(ERROR, "no Python function is currently executing");
 
    return PLy_execution_contexts;
}

References elog, ERROR, and PLy_execution_contexts.

Referenced by plpython_return_error_callback(), plpython_trigger_error_callback(), PLy_commit(), PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_cursor_plan(), PLy_cursor_query(), PLy_input_convert(), PLy_input_from_tuple(), PLy_rollback(), PLy_spi_execute_fetch_result(), PLy_spi_execute_plan(), PLy_spi_execute_query(), PLy_spi_prepare(), PLy_traceback(), PLyDict_FromComposite(), and PLyObject_ToComposite().

PLy_get_scratch_context()

MemoryContext PLy_get_scratch_context

(

PLyExecutionContext *

context

)

Definition at line 376 of file plpy_main.c.

{
    /*
     * A scratch context might never be needed in a given plpython procedure,
     * so allocate it on first request.
     */
    if (context->scratch_ctx == NULL)
        context->scratch_ctx =
            AllocSetContextCreate(TopTransactionContext,
                                  "PL/Python scratch context",
                                  ALLOCSET_DEFAULT_SIZES);
    return context->scratch_ctx;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, context, and TopTransactionContext.

Referenced by PLy_input_convert(), and PLy_input_from_tuple().

PLy_init_interp()

static void PLy_init_interp ( void  )

static

Definition at line 138 of file plpy_main.c.

{
    static PyObject *PLy_interp_safe_globals = NULL;
    PyObject   *mainmod;
 
    mainmod = PyImport_AddModule("__main__");
    if (mainmod == NULL || PyErr_Occurred())
        PLy_elog(ERROR, "could not import \"__main__\" module");
    Py_INCREF(mainmod);
    PLy_interp_globals = PyModule_GetDict(mainmod);
    PLy_interp_safe_globals = PyDict_New();
    if (PLy_interp_safe_globals == NULL)
        PLy_elog(ERROR, NULL);
    PyDict_SetItemString(PLy_interp_globals, "GD", PLy_interp_safe_globals);
    Py_DECREF(mainmod);
    if (PLy_interp_globals == NULL || PyErr_Occurred())
        PLy_elog(ERROR, "could not initialize globals");
}

References ERROR, PLy_elog, and PLy_interp_globals.

Referenced by PLy_initialize().

PLy_initialize()

static void PLy_initialize ( void  )

static

Definition at line 95 of file plpy_main.c.

{
    static bool inited = false;
 
    /*
     * Check for multiple Python libraries before actively doing anything with
     * libpython.  This must be repeated on each entry to PL/Python, in case a
     * conflicting library got loaded since we last looked.
     *
     * It is attractive to weaken this error from FATAL to ERROR, but there
     * would be corner cases, so it seems best to be conservative.
     */
    if (*plpython_version_bitmask_ptr != (1 << PY_MAJOR_VERSION))
        ereport(FATAL,
                (errmsg("multiple Python libraries are present in session"),
                 errdetail("Only one Python major version can be used in one session.")));
 
    /* The rest should only be done once per session */
    if (inited)
        return;
 
    PyImport_AppendInittab("plpy", PyInit_plpy);
    Py_Initialize();
    PyImport_ImportModule("plpy");
    PLy_init_interp();
    PLy_init_plpy();
    if (PyErr_Occurred())
        PLy_elog(FATAL, "untrapped error in initialization");
 
    init_procedure_caches();
 
    explicit_subtransactions = NIL;
 
    PLy_execution_contexts = NULL;
 
    inited = true;
}

References ereport, errdetail(), errmsg(), explicit_subtransactions, FATAL, init_procedure_caches(), NIL, plpython_version_bitmask_ptr, PLy_elog, PLy_execution_contexts, PLy_init_interp(), PLy_init_plpy(), and PyInit_plpy().

Referenced by plpython3_call_handler(), plpython3_inline_handler(), and plpython3_validator().

PLy_pop_execution_context()

static void PLy_pop_execution_context ( void  )

static

Definition at line 407 of file plpy_main.c.

{
    PLyExecutionContext *context = PLy_execution_contexts;
 
    if (context == NULL)
        elog(ERROR, "no Python function is currently executing");
 
    PLy_execution_contexts = context->next;
 
    if (context->scratch_ctx)
        MemoryContextDelete(context->scratch_ctx);
    pfree(context);
}

References context, elog, ERROR, MemoryContextDelete(), pfree(), and PLy_execution_contexts.

Referenced by plpython3_call_handler(), and plpython3_inline_handler().

PLy_procedure_is_trigger()

static bool PLy_procedure_is_trigger ( Form_pg_proc  procStruct )

static

Definition at line 339 of file plpy_main.c.

{
    return (procStruct->prorettype == TRIGGEROID);
}

Referenced by plpython3_validator().

PLy_push_execution_context()

static PLyExecutionContext * PLy_push_execution_context ( bool  atomic_context )

static

Definition at line 391 of file plpy_main.c.

{
    PLyExecutionContext *context;
 
    /* Pick a memory context similar to what SPI uses. */
    context = (PLyExecutionContext *)
        MemoryContextAlloc(atomic_context ? TopTransactionContext : PortalContext,
                           sizeof(PLyExecutionContext));
    context->curr_proc = NULL;
    context->scratch_ctx = NULL;
    context->next = PLy_execution_contexts;
    PLy_execution_contexts = context;
    return context;
}

References context, MemoryContextAlloc(), PLy_execution_contexts, PortalContext, and TopTransactionContext.

Referenced by plpython3_call_handler(), and plpython3_inline_handler().

Variable Documentation

PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 31 of file plpy_main.c.

plpython_version_bitmask

int plpython_version_bitmask = 0

static

Definition at line 48 of file plpy_main.c.

Referenced by _PG_init().

plpython_version_bitmask_ptr

int* plpython_version_bitmask_ptr = NULL

static

Definition at line 47 of file plpy_main.c.

Referenced by _PG_init(), and PLy_initialize().

PLy_execution_contexts

PLyExecutionContext* PLy_execution_contexts = NULL

static

Definition at line 54 of file plpy_main.c.

Referenced by PLy_current_execution_context(), PLy_initialize(), PLy_pop_execution_context(), and PLy_push_execution_context().

PLy_interp_globals

PyObject* PLy_interp_globals = NULL

Definition at line 51 of file plpy_main.c.

Referenced by PLy_init_interp(), and PLy_procedure_compile().