#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 "utils/guc.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/syscache.h"
#include "plpython.h"
#include "plpy_main.h"
#include "plpy_elog.h"
#include "plpy_exec.h"
#include "plpy_plpymodule.h"
#include "plpy_procedure.h"
#include "plpy_subxactobject.h"

Include dependency graph for plpy_main.c:

Functions
void	_PG_init (void)

	PG_FUNCTION_INFO_V1 (plpython_validator)

	PG_FUNCTION_INFO_V1 (plpython_call_handler)

	PG_FUNCTION_INFO_V1 (plpython_inline_handler)

	PG_FUNCTION_INFO_V1 (plpython2_validator)

	PG_FUNCTION_INFO_V1 (plpython2_call_handler)

	PG_FUNCTION_INFO_V1 (plpython2_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 (void)

static void	PLy_pop_execution_context (void)

static void	PLy_initialize (void)

Datum	plpython_validator (PG_FUNCTION_ARGS)

Datum	plpython2_validator (PG_FUNCTION_ARGS)

Datum	plpython_call_handler (PG_FUNCTION_ARGS)

Datum	plpython2_call_handler (PG_FUNCTION_ARGS)

Datum	plpython_inline_handler (PG_FUNCTION_ARGS)

Datum	plpython2_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

void _PG_init ( void )

Definition at line 78 of file plpy_main.c.

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

 {
     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.
      */
     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);
 }

PG_FUNCTION_INFO_V1 ( plpython_validator )

PG_FUNCTION_INFO_V1 ( plpython_call_handler )

PG_FUNCTION_INFO_V1 ( plpython_inline_handler )

PG_FUNCTION_INFO_V1 ( plpython2_validator )

PG_FUNCTION_INFO_V1 ( plpython2_call_handler )

PG_FUNCTION_INFO_V1 ( plpython2_inline_handler )

Datum plpython2_call_handler ( PG_FUNCTION_ARGS )

Definition at line 287 of file plpy_main.c.

References plpython_call_handler().

 {
     return plpython_call_handler(fcinfo);
 }

Datum plpython2_inline_handler ( PG_FUNCTION_ARGS )

Definition at line 367 of file plpy_main.c.

References plpython_inline_handler().

 {
     return plpython_inline_handler(fcinfo);
 }

Datum plpython2_validator ( PG_FUNCTION_ARGS )

Definition at line 212 of file plpy_main.c.

References plpython_validator().

 {
     /* call plpython validator with our fcinfo so it gets our oid */
     return plpython_validator(fcinfo);
 }

Datum plpython_call_handler ( PG_FUNCTION_ARGS )

Definition at line 220 of file plpy_main.c.

References ErrorContextCallback::callback, CALLED_AS_TRIGGER, PLyExecutionContext::curr_proc, elog, ERROR, error_context_stack, InvalidOid, 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(), and SPI_OK_CONNECT.

Referenced by plpython2_call_handler().

 {
     Datum       retval;
     PLyExecutionContext *exec_ctx;
     ErrorContextCallback plerrcontext;
 
     PLy_initialize();
 
     /* Note: SPI_finish() happens in plpy_exec.c, which is dubious design */
     if (SPI_connect() != 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.  (plpython_error_callback expects the stack entry
      * to be there, so we have to make the context first.)
      */
     exec_ctx = PLy_push_execution_context();
 
     /*
      * Setup error traceback support for ereport()
      */
     plerrcontext.callback = plpython_error_callback;
     plerrcontext.previous = error_context_stack;
     error_context_stack = &plerrcontext;
 
     PG_TRY();
     {
         Oid         funcoid = fcinfo->flinfo->fn_oid;
         PLyProcedure *proc;
 
         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();
 
     /* Pop the error context stack */
     error_context_stack = plerrcontext.previous;
     /* ... and then the execution context */
     PLy_pop_execution_context();
 
     return retval;
 }

static void plpython_error_callback ( void * arg )

static

Definition at line 382 of file plpy_main.c.

References PLyExecutionContext::curr_proc, errcontext, PLy_current_execution_context(), and PLy_procedure_name().

Referenced by plpython_call_handler().

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

static void plpython_inline_error_callback ( void * arg )

static

Definition at line 392 of file plpy_main.c.

References errcontext.

Referenced by plpython_inline_handler().

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

Datum plpython_inline_handler ( PG_FUNCTION_ARGS )

Definition at line 294 of file plpy_main.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate(), ErrorContextCallback::callback, PLyExecutionContext::curr_proc, CurrentMemoryContext, PLyTypeOutput::d, DatumGetPointer, elog, ERROR, error_context_stack, FunctionCallInfoData::flinfo, FmgrInfo::fn_mcxt, FmgrInfo::fn_oid, InvalidOid, PLyProcedure::langid, InlineCodeBlock::langOid, PLyProcedure::mcxt, MemoryContextStrdup(), MemSet, PLyTypeInfo::out, 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, InlineCodeBlock::source_text, SPI_connect(), SPI_OK_CONNECT, TopMemoryContext, PLyObToDatum::typoid, and VOIDOID.

Referenced by plpython2_inline_handler().

 {
     InlineCodeBlock *codeblock = (InlineCodeBlock *) DatumGetPointer(PG_GETARG_DATUM(0));
     FunctionCallInfoData fake_fcinfo;
     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() != SPI_OK_CONNECT)
         elog(ERROR, "SPI_connect failed");
 
     MemSet(&fake_fcinfo, 0, sizeof(fake_fcinfo));
     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;
     proc.result.out.d.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.  (plpython_inline_error_callback doesn't currently
      * need the stack entry, but for consistency with plpython_call_handler we
      * do it in this order.)
      */
     exec_ctx = PLy_push_execution_context();
 
     /*
      * Setup error traceback support for ereport()
      */
     plerrcontext.callback = plpython_inline_error_callback;
     plerrcontext.previous = error_context_stack;
     error_context_stack = &plerrcontext;
 
     PG_TRY();
     {
         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();
 
     /* Pop the error context stack */
     error_context_stack = plerrcontext.previous;
     /* ... and then the execution context */
     PLy_pop_execution_context();
 
     /* Now clean up the transient procedure we made */
     PLy_procedure_delete(&proc);
 
     PG_RETURN_VOID();
 }

Datum plpython_validator ( PG_FUNCTION_ARGS )

Definition at line 178 of file plpy_main.c.

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(), PROCOID, ReleaseSysCache(), and SearchSysCache1.

Referenced by plpython2_validator().

 {
     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();
 }

PLyExecutionContext* PLy_current_execution_context ( void )

Definition at line 398 of file plpy_main.c.

References elog, ERROR, NULL, and PLy_execution_contexts.

Referenced by plpython_error_callback(), plpython_return_error_callback(), plpython_trigger_error_callback(), PLy_cursor_plan(), PLy_cursor_query(), PLy_input_tuple_funcs(), PLy_output_tuple_funcs(), PLy_spi_execute_plan(), PLy_spi_execute_query(), PLy_spi_prepare(), PLy_traceback(), PLyDict_FromTuple(), and PLyString_ToComposite().

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

MemoryContext PLy_get_scratch_context ( PLyExecutionContext * context )

Definition at line 407 of file plpy_main.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate(), NULL, PLyExecutionContext::scratch_ctx, and TopTransactionContext.

Referenced by PLyDict_FromTuple().

 {
     /*
      * 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;
 }

static void PLy_init_interp ( void )

static

Definition at line 158 of file plpy_main.c.

References ERROR, NULL, PLy_elog(), and PLy_interp_globals.

Referenced by PLy_initialize().

 {
     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, "could not create globals");
     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");
 }

static void PLy_initialize ( void )

static

Definition at line 111 of file plpy_main.c.

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

Referenced by plpython_call_handler(), plpython_inline_handler(), and plpython_validator().

 {
     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;
 
 #if PY_MAJOR_VERSION >= 3
     PyImport_AppendInittab("plpy", PyInit_plpy);
 #endif
     Py_Initialize();
 #if PY_MAJOR_VERSION >= 3
     PyImport_ImportModule("plpy");
 #endif
     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;
 }

static void PLy_pop_execution_context ( void )

static

Definition at line 436 of file plpy_main.c.

References elog, ERROR, MemoryContextDelete(), PLyExecutionContext::next, NULL, pfree(), PLy_execution_contexts, and PLyExecutionContext::scratch_ctx.

Referenced by plpython_call_handler(), and plpython_inline_handler().

 {
     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);
 }

static bool PLy_procedure_is_trigger ( Form_pg_proc procStruct )

static

Definition at line 374 of file plpy_main.c.

References OPAQUEOID, and TRIGGEROID.

Referenced by plpython_validator().

 {
     return (procStruct->prorettype == TRIGGEROID ||
             (procStruct->prorettype == OPAQUEOID &&
              procStruct->pronargs == 0));
 }

static PLyExecutionContext * PLy_push_execution_context ( void )

static

Definition at line 422 of file plpy_main.c.

References PLyExecutionContext::curr_proc, MemoryContextAlloc(), PLyExecutionContext::next, NULL, PLy_execution_contexts, PLyExecutionContext::scratch_ctx, and TopTransactionContext.

Referenced by plpython_call_handler(), and plpython_inline_handler().

 {
     PLyExecutionContext *context;
 
     context = (PLyExecutionContext *)
         MemoryContextAlloc(TopTransactionContext, sizeof(PLyExecutionContext));
     context->curr_proc = NULL;
     context->scratch_ctx = NULL;
     context->next = PLy_execution_contexts;
     PLy_execution_contexts = context;
     return context;
 }

Variable Documentation

PG_MODULE_MAGIC

Definition at line 44 of file plpy_main.c.

int plpython_version_bitmask = 0

static

Definition at line 68 of file plpy_main.c.

Referenced by _PG_init().

int* plpython_version_bitmask_ptr = NULL

static

Definition at line 67 of file plpy_main.c.

Referenced by _PG_init(), and PLy_initialize().

PLyExecutionContext* PLy_execution_contexts = NULL

static

Definition at line 74 of file plpy_main.c.

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

PyObject* PLy_interp_globals = NULL

Definition at line 71 of file plpy_main.c.

Referenced by PLy_init_interp(), and PLy_procedure_compile().

Functions

Variables

Function Documentation

Variable Documentation