#include "postgres.h"
#include "access/htup_details.h"
#include "access/xact.h"
#include "catalog/pg_type.h"
#include "commands/trigger.h"
#include "executor/spi.h"
#include "funcapi.h"
#include "plpy_elog.h"
#include "plpy_exec.h"
#include "plpy_main.h"
#include "plpy_procedure.h"
#include "plpy_subxactobject.h"
#include "plpython.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/typcache.h"

Include dependency graph for plpy_exec.c:

Data Structures
struct	PLySRFState

Typedefs
typedef struct PLySRFState	PLySRFState

Functions
static PyObject *	PLy_function_build_args (FunctionCallInfo fcinfo, PLyProcedure *proc)

static PLySavedArgs *	PLy_function_save_args (PLyProcedure *proc)

static void	PLy_function_restore_args (PLyProcedure proc, PLySavedArgs savedargs)

static void	PLy_function_drop_args (PLySavedArgs *savedargs)

static void	PLy_global_args_push (PLyProcedure *proc)

static void	PLy_global_args_pop (PLyProcedure *proc)

static void	plpython_srf_cleanup_callback (void *arg)

static void	plpython_return_error_callback (void *arg)

static PyObject *	PLy_trigger_build_args (FunctionCallInfo fcinfo, PLyProcedure proc, HeapTuple rv)

static HeapTuple	PLy_modify_tuple (PLyProcedure proc, PyObject pltd, TriggerData *tdata, HeapTuple otup)

static void	plpython_trigger_error_callback (void *arg)

static PyObject *	PLy_procedure_call (PLyProcedure proc, const char kargs, PyObject *vargs)

static void	PLy_abort_open_subtransactions (int save_subxact_level)

Datum	PLy_exec_function (FunctionCallInfo fcinfo, PLyProcedure *proc)

HeapTuple	PLy_exec_trigger (FunctionCallInfo fcinfo, PLyProcedure *proc)

Typedef Documentation

◆ PLySRFState

typedef struct PLySRFState PLySRFState

Function Documentation

◆ plpython_return_error_callback()

static void plpython_return_error_callback ( void * arg )

static

Definition at line 671 of file plpy_exec.c.

 {
     PLyExecutionContext *exec_ctx = PLy_current_execution_context();
  
     if (exec_ctx->curr_proc &&
         !exec_ctx->curr_proc->is_procedure)
         errcontext("while creating return value");
 }

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

Referenced by PLy_exec_function().

◆ plpython_srf_cleanup_callback()

static void plpython_srf_cleanup_callback ( void * arg )

static

Definition at line 657 of file plpy_exec.c.

 {
     PLySRFState *srfstate = (PLySRFState *) arg;
  
     /* Release refcount on the iter, if we still have one */
     Py_XDECREF(srfstate->iter);
     srfstate->iter = NULL;
     /* And drop any saved args; we won't need them */
     if (srfstate->savedargs)
         PLy_function_drop_args(srfstate->savedargs);
     srfstate->savedargs = NULL;
 }

References arg, PLySRFState::iter, PLy_function_drop_args(), and PLySRFState::savedargs.

Referenced by PLy_exec_function().

◆ plpython_trigger_error_callback()

static void plpython_trigger_error_callback ( void * arg )

static

Definition at line 1028 of file plpy_exec.c.

 {
     PLyExecutionContext *exec_ctx = PLy_current_execution_context();
  
     if (exec_ctx->curr_proc)
         errcontext("while modifying trigger row");
 }

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

Referenced by PLy_modify_tuple().

◆ PLy_abort_open_subtransactions()

static void PLy_abort_open_subtransactions ( int save_subxact_level )

static

Definition at line 1080 of file plpy_exec.c.

 {
     Assert(save_subxact_level >= 0);
  
     while (list_length(explicit_subtransactions) > save_subxact_level)
     {
         PLySubtransactionData *subtransactiondata;
  
         Assert(explicit_subtransactions != NIL);
  
         ereport(WARNING,
                 (errmsg("forcibly aborting a subtransaction that has not been exited")));
  
         RollbackAndReleaseCurrentSubTransaction();
  
         subtransactiondata = (PLySubtransactionData *) linitial(explicit_subtransactions);
         explicit_subtransactions = list_delete_first(explicit_subtransactions);
  
         MemoryContextSwitchTo(subtransactiondata->oldcontext);
         CurrentResourceOwner = subtransactiondata->oldowner;
         pfree(subtransactiondata);
     }
 }

References Assert, CurrentResourceOwner, ereport, errmsg(), explicit_subtransactions, linitial, list_delete_first(), list_length(), MemoryContextSwitchTo(), NIL, PLySubtransactionData::oldcontext, PLySubtransactionData::oldowner, pfree(), RollbackAndReleaseCurrentSubTransaction(), and WARNING.

Referenced by PLy_procedure_call().

◆ PLy_exec_function()

Datum PLy_exec_function	(	FunctionCallInfo	fcinfo,
		PLyProcedure *	proc
	)

Definition at line 55 of file plpy_exec.c.

 {
     bool        is_setof = proc->is_setof;
     Datum       rv;
     PyObject   *volatile plargs = NULL;
     PyObject   *volatile plrv = NULL;
     FuncCallContext *volatile funcctx = NULL;
     PLySRFState *volatile srfstate = NULL;
     ErrorContextCallback plerrcontext;
  
     /*
      * If the function is called recursively, we must push outer-level
      * arguments into the stack.  This must be immediately before the PG_TRY
      * to ensure that the corresponding pop happens.
      */
     PLy_global_args_push(proc);
  
     PG_TRY();
     {
         if (is_setof)
         {
             /* First Call setup */
             if (SRF_IS_FIRSTCALL())
             {
                 funcctx = SRF_FIRSTCALL_INIT();
                 srfstate = (PLySRFState *)
                     MemoryContextAllocZero(funcctx->multi_call_memory_ctx,
                                            sizeof(PLySRFState));
                 /* Immediately register cleanup callback */
                 srfstate->callback.func = plpython_srf_cleanup_callback;
                 srfstate->callback.arg = (void *) srfstate;
                 MemoryContextRegisterResetCallback(funcctx->multi_call_memory_ctx,
                                                    &srfstate->callback);
                 funcctx->user_fctx = (void *) srfstate;
             }
             /* Every call setup */
             funcctx = SRF_PERCALL_SETUP();
             Assert(funcctx != NULL);
             srfstate = (PLySRFState *) funcctx->user_fctx;
             Assert(srfstate != NULL);
         }
  
         if (srfstate == NULL || srfstate->iter == NULL)
         {
             /*
              * Non-SETOF function or first time for SETOF function: build
              * args, then actually execute the function.
              */
             plargs = PLy_function_build_args(fcinfo, proc);
             plrv = PLy_procedure_call(proc, "args", plargs);
             Assert(plrv != NULL);
         }
         else
         {
             /*
              * Second or later call for a SETOF function: restore arguments in
              * globals dict to what they were when we left off.  We must do
              * this in case multiple evaluations of the same SETOF function
              * are interleaved.  It's a bit annoying, since the iterator may
              * not look at the arguments at all, but we have no way to know
              * that.  Fortunately this isn't terribly expensive.
              */
             if (srfstate->savedargs)
                 PLy_function_restore_args(proc, srfstate->savedargs);
             srfstate->savedargs = NULL; /* deleted by restore_args */
         }
  
         /*
          * If it returns a set, call the iterator to get the next return item.
          * We stay in the SPI context while doing this, because PyIter_Next()
          * calls back into Python code which might contain SPI calls.
          */
         if (is_setof)
         {
             if (srfstate->iter == NULL)
             {
                 /* first time -- do checks and setup */
                 ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
  
                 if (!rsi || !IsA(rsi, ReturnSetInfo) ||
                     (rsi->allowedModes & SFRM_ValuePerCall) == 0)
                 {
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("unsupported set function return mode"),
                              errdetail("PL/Python set-returning functions only support returning one value per call.")));
                 }
                 rsi->returnMode = SFRM_ValuePerCall;
  
                 /* Make iterator out of returned object */
                 srfstate->iter = PyObject_GetIter(plrv);
  
                 Py_DECREF(plrv);
                 plrv = NULL;
  
                 if (srfstate->iter == NULL)
                     ereport(ERROR,
                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                              errmsg("returned object cannot be iterated"),
                              errdetail("PL/Python set-returning functions must return an iterable object.")));
             }
  
             /* Fetch next from iterator */
             plrv = PyIter_Next(srfstate->iter);
             if (plrv == NULL)
             {
                 /* Iterator is exhausted or error happened */
                 bool        has_error = (PyErr_Occurred() != NULL);
  
                 Py_DECREF(srfstate->iter);
                 srfstate->iter = NULL;
  
                 if (has_error)
                     PLy_elog(ERROR, "error fetching next item from iterator");
  
                 /* Pass a null through the data-returning steps below */
                 Py_INCREF(Py_None);
                 plrv = Py_None;
             }
             else
             {
                 /*
                  * This won't be last call, so save argument values.  We do
                  * this again each time in case the iterator is changing those
                  * values.
                  */
                 srfstate->savedargs = PLy_function_save_args(proc);
             }
         }
  
         /*
          * Disconnect from SPI manager and then create the return values datum
          * (if the input function does a palloc for it this must not be
          * allocated in the SPI memory context because SPI_finish would free
          * it).
          */
         if (SPI_finish() != SPI_OK_FINISH)
             elog(ERROR, "SPI_finish failed");
  
         plerrcontext.callback = plpython_return_error_callback;
         plerrcontext.previous = error_context_stack;
         error_context_stack = &plerrcontext;
  
         /*
          * For a procedure or function declared to return void, the Python
          * return value must be None. For void-returning functions, we also
          * treat a None return value as a special "void datum" rather than
          * NULL (as is the case for non-void-returning functions).
          */
         if (proc->result.typoid == VOIDOID)
         {
             if (plrv != Py_None)
             {
                 if (proc->is_procedure)
                     ereport(ERROR,
                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                              errmsg("PL/Python procedure did not return None")));
                 else
                     ereport(ERROR,
                             (errcode(ERRCODE_DATATYPE_MISMATCH),
                              errmsg("PL/Python function with return type \"void\" did not return None")));
             }
  
             fcinfo->isnull = false;
             rv = (Datum) 0;
         }
         else if (plrv == Py_None &&
                  srfstate && srfstate->iter == NULL)
         {
             /*
              * In a SETOF function, the iteration-ending null isn't a real
              * value; don't pass it through the input function, which might
              * complain.
              */
             fcinfo->isnull = true;
             rv = (Datum) 0;
         }
         else
         {
             /* Normal conversion of result */
             rv = PLy_output_convert(&proc->result, plrv,
                                     &fcinfo->isnull);
         }
     }
     PG_CATCH();
     {
         /* Pop old arguments from the stack if they were pushed above */
         PLy_global_args_pop(proc);
  
         Py_XDECREF(plargs);
         Py_XDECREF(plrv);
  
         /*
          * If there was an error within a SRF, the iterator might not have
          * been exhausted yet.  Clear it so the next invocation of the
          * function will start the iteration again.  (This code is probably
          * unnecessary now; plpython_srf_cleanup_callback should take care of
          * cleanup.  But it doesn't hurt anything to do it here.)
          */
         if (srfstate)
         {
             Py_XDECREF(srfstate->iter);
             srfstate->iter = NULL;
             /* And drop any saved args; we won't need them */
             if (srfstate->savedargs)
                 PLy_function_drop_args(srfstate->savedargs);
             srfstate->savedargs = NULL;
         }
  
         PG_RE_THROW();
     }
     PG_END_TRY();
  
     error_context_stack = plerrcontext.previous;
  
     /* Pop old arguments from the stack if they were pushed above */
     PLy_global_args_pop(proc);
  
     Py_XDECREF(plargs);
     Py_DECREF(plrv);
  
     if (srfstate)
     {
         /* We're in a SRF, exit appropriately */
         if (srfstate->iter == NULL)
         {
             /* Iterator exhausted, so we're done */
             SRF_RETURN_DONE(funcctx);
         }
         else if (fcinfo->isnull)
             SRF_RETURN_NEXT_NULL(funcctx);
         else
             SRF_RETURN_NEXT(funcctx, rv);
     }
  
     /* Plain function, just return the Datum value (possibly null) */
     return rv;
 }

References ReturnSetInfo::allowedModes, MemoryContextCallback::arg, Assert, ErrorContextCallback::callback, PLySRFState::callback, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, error_context_stack, MemoryContextCallback::func, if(), PLyProcedure::is_procedure, PLyProcedure::is_setof, IsA, FunctionCallInfoBaseData::isnull, PLySRFState::iter, MemoryContextAllocZero(), MemoryContextRegisterResetCallback(), FuncCallContext::multi_call_memory_ctx, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, plpython_return_error_callback(), plpython_srf_cleanup_callback(), PLy_elog, PLy_function_build_args(), PLy_function_drop_args(), PLy_function_restore_args(), PLy_function_save_args(), PLy_global_args_pop(), PLy_global_args_push(), PLy_output_convert(), PLy_procedure_call(), ErrorContextCallback::previous, PLyProcedure::result, FunctionCallInfoBaseData::resultinfo, ReturnSetInfo::returnMode, PLySRFState::savedargs, SFRM_ValuePerCall, SPI_finish(), SPI_OK_FINISH, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, SRF_RETURN_NEXT_NULL, PLyObToDatum::typoid, and FuncCallContext::user_fctx.

Referenced by plpython3_call_handler(), and plpython3_inline_handler().

◆ PLy_exec_trigger()

HeapTuple PLy_exec_trigger	(	FunctionCallInfo	fcinfo,
		PLyProcedure *	proc
	)

Definition at line 305 of file plpy_exec.c.

 {
     HeapTuple   rv = NULL;
     PyObject   *volatile plargs = NULL;
     PyObject   *volatile plrv = NULL;
     TriggerData *tdata;
     TupleDesc   rel_descr;
  
     Assert(CALLED_AS_TRIGGER(fcinfo));
     tdata = (TriggerData *) fcinfo->context;
  
     /*
      * Input/output conversion for trigger tuples.  We use the result and
      * result_in fields to store the tuple conversion info.  We do this over
      * again on each call to cover the possibility that the relation's tupdesc
      * changed since the trigger was last called.  The PLy_xxx_setup_func
      * calls should only happen once, but PLy_input_setup_tuple and
      * PLy_output_setup_tuple are responsible for not doing repetitive work.
      */
     rel_descr = RelationGetDescr(tdata->tg_relation);
     if (proc->result.typoid != rel_descr->tdtypeid)
         PLy_output_setup_func(&proc->result, proc->mcxt,
                               rel_descr->tdtypeid,
                               rel_descr->tdtypmod,
                               proc);
     if (proc->result_in.typoid != rel_descr->tdtypeid)
         PLy_input_setup_func(&proc->result_in, proc->mcxt,
                              rel_descr->tdtypeid,
                              rel_descr->tdtypmod,
                              proc);
     PLy_output_setup_tuple(&proc->result, rel_descr, proc);
     PLy_input_setup_tuple(&proc->result_in, rel_descr, proc);
  
     PG_TRY();
     {
         int         rc PG_USED_FOR_ASSERTS_ONLY;
  
         rc = SPI_register_trigger_data(tdata);
         Assert(rc >= 0);
  
         plargs = PLy_trigger_build_args(fcinfo, proc, &rv);
         plrv = PLy_procedure_call(proc, "TD", plargs);
  
         Assert(plrv != NULL);
  
         /*
          * Disconnect from SPI manager
          */
         if (SPI_finish() != SPI_OK_FINISH)
             elog(ERROR, "SPI_finish failed");
  
         /*
          * return of None means we're happy with the tuple
          */
         if (plrv != Py_None)
         {
             char       *srv;
  
             if (PyUnicode_Check(plrv))
                 srv = PLyUnicode_AsString(plrv);
             else
             {
                 ereport(ERROR,
                         (errcode(ERRCODE_DATA_EXCEPTION),
                          errmsg("unexpected return value from trigger procedure"),
                          errdetail("Expected None or a string.")));
                 srv = NULL;     /* keep compiler quiet */
             }
  
             if (pg_strcasecmp(srv, "SKIP") == 0)
                 rv = NULL;
             else if (pg_strcasecmp(srv, "MODIFY") == 0)
             {
                 if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event) ||
                     TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
                     rv = PLy_modify_tuple(proc, plargs, tdata, rv);
                 else
                     ereport(WARNING,
                             (errmsg("PL/Python trigger function returned \"MODIFY\" in a DELETE trigger -- ignored")));
             }
             else if (pg_strcasecmp(srv, "OK") != 0)
             {
                 /*
                  * accept "OK" as an alternative to None; otherwise, raise an
                  * error
                  */
                 ereport(ERROR,
                         (errcode(ERRCODE_DATA_EXCEPTION),
                          errmsg("unexpected return value from trigger procedure"),
                          errdetail("Expected None, \"OK\", \"SKIP\", or \"MODIFY\".")));
             }
         }
     }
     PG_FINALLY();
     {
         Py_XDECREF(plargs);
         Py_XDECREF(plrv);
     }
     PG_END_TRY();
  
     return rv;
 }

References Assert, CALLED_AS_TRIGGER, FunctionCallInfoBaseData::context, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, PLyProcedure::mcxt, PG_END_TRY, PG_FINALLY, pg_strcasecmp(), PG_TRY, PG_USED_FOR_ASSERTS_ONLY, PLy_input_setup_func(), PLy_input_setup_tuple(), PLy_modify_tuple(), PLy_output_setup_func(), PLy_output_setup_tuple(), PLy_procedure_call(), PLy_trigger_build_args(), PLyUnicode_AsString(), RelationGetDescr, PLyProcedure::result, PLyProcedure::result_in, SPI_finish(), SPI_OK_FINISH, SPI_register_trigger_data(), TupleDescData::tdtypeid, TupleDescData::tdtypmod, TriggerData::tg_event, TriggerData::tg_relation, TRIGGER_FIRED_BY_INSERT, TRIGGER_FIRED_BY_UPDATE, PLyDatumToOb::typoid, PLyObToDatum::typoid, and WARNING.

Referenced by plpython3_call_handler().

◆ PLy_function_build_args()

static PyObject * PLy_function_build_args	(	FunctionCallInfo	fcinfo,
		PLyProcedure *	proc
	)

static

Definition at line 411 of file plpy_exec.c.

 {
     PyObject   *volatile arg = NULL;
     PyObject   *args;
     int         i;
  
     /*
      * Make any Py*_New() calls before the PG_TRY block so that we can quickly
      * return NULL on failure.  We can't return within the PG_TRY block, else
      * we'd miss unwinding the exception stack.
      */
     args = PyList_New(proc->nargs);
     if (!args)
         return NULL;
  
     PG_TRY();
     {
         for (i = 0; i < proc->nargs; i++)
         {
             PLyDatumToOb *arginfo = &proc->args[i];
  
             if (fcinfo->args[i].isnull)
                 arg = NULL;
             else
                 arg = PLy_input_convert(arginfo, fcinfo->args[i].value);
  
             if (arg == NULL)
             {
                 Py_INCREF(Py_None);
                 arg = Py_None;
             }
  
             if (PyList_SetItem(args, i, arg) == -1)
                 PLy_elog(ERROR, "PyList_SetItem() failed, while setting up arguments");
  
             if (proc->argnames && proc->argnames[i] &&
                 PyDict_SetItemString(proc->globals, proc->argnames[i], arg) == -1)
                 PLy_elog(ERROR, "PyDict_SetItemString() failed, while setting up arguments");
             arg = NULL;
         }
  
         /* Set up output conversion for functions returning RECORD */
         if (proc->result.typoid == RECORDOID)
         {
             TupleDesc   desc;
  
             if (get_call_result_type(fcinfo, NULL, &desc) != TYPEFUNC_COMPOSITE)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("function returning record called in context "
                                 "that cannot accept type record")));
  
             /* cache the output conversion functions */
             PLy_output_setup_record(&proc->result, desc, proc);
         }
     }
     PG_CATCH();
     {
         Py_XDECREF(arg);
         Py_XDECREF(args);
  
         PG_RE_THROW();
     }
     PG_END_TRY();
  
     return args;
 }

References arg, PLyProcedure::argnames, generate_unaccent_rules::args, FunctionCallInfoBaseData::args, PLyProcedure::args, ereport, errcode(), errmsg(), ERROR, get_call_result_type(), PLyProcedure::globals, i, NullableDatum::isnull, PLyProcedure::nargs, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PLy_elog, PLy_input_convert(), PLy_output_setup_record(), PLyProcedure::result, TYPEFUNC_COMPOSITE, PLyObToDatum::typoid, and NullableDatum::value.

Referenced by PLy_exec_function().

◆ PLy_function_drop_args()

static void PLy_function_drop_args ( PLySavedArgs * savedargs )

static

Definition at line 561 of file plpy_exec.c.

 {
     int         i;
  
     /* Drop references for named args */
     for (i = 0; i < savedargs->nargs; i++)
     {
         Py_XDECREF(savedargs->namedargs[i]);
     }
  
     /* Drop ref to the "args" object, too */
     Py_XDECREF(savedargs->args);
  
     /* And free the PLySavedArgs struct */
     pfree(savedargs);
 }

References PLySavedArgs::args, i, PLySavedArgs::namedargs, PLySavedArgs::nargs, and pfree().

Referenced by plpython_srf_cleanup_callback(), and PLy_exec_function().

◆ PLy_function_restore_args()

static void PLy_function_restore_args	(	PLyProcedure *	proc,
		PLySavedArgs *	savedargs
	)

static

Definition at line 528 of file plpy_exec.c.

 {
     /* Restore named arguments into their slots in the globals dict */
     if (proc->argnames)
     {
         int         i;
  
         for (i = 0; i < savedargs->nargs; i++)
         {
             if (proc->argnames[i] && savedargs->namedargs[i])
             {
                 PyDict_SetItemString(proc->globals, proc->argnames[i],
                                      savedargs->namedargs[i]);
                 Py_DECREF(savedargs->namedargs[i]);
             }
         }
     }
  
     /* Restore the "args" object, too */
     if (savedargs->args)
     {
         PyDict_SetItemString(proc->globals, "args", savedargs->args);
         Py_DECREF(savedargs->args);
     }
  
     /* And free the PLySavedArgs struct */
     pfree(savedargs);
 }

References PLyProcedure::argnames, PLySavedArgs::args, PLyProcedure::globals, i, PLySavedArgs::namedargs, PLySavedArgs::nargs, and pfree().

Referenced by PLy_exec_function(), and PLy_global_args_pop().

◆ PLy_function_save_args()

static PLySavedArgs * PLy_function_save_args ( PLyProcedure * proc )

static

Definition at line 489 of file plpy_exec.c.

 {
     PLySavedArgs *result;
  
     /* saved args are always allocated in procedure's context */
     result = (PLySavedArgs *)
         MemoryContextAllocZero(proc->mcxt,
                                offsetof(PLySavedArgs, namedargs) +
                                proc->nargs * sizeof(PyObject *));
     result->nargs = proc->nargs;
  
     /* Fetch the "args" list */
     result->args = PyDict_GetItemString(proc->globals, "args");
     Py_XINCREF(result->args);
  
     /* Fetch all the named arguments */
     if (proc->argnames)
     {
         int         i;
  
         for (i = 0; i < result->nargs; i++)
         {
             if (proc->argnames[i])
             {
                 result->namedargs[i] = PyDict_GetItemString(proc->globals,
                                                             proc->argnames[i]);
                 Py_XINCREF(result->namedargs[i]);
             }
         }
     }
  
     return result;
 }

References PLyProcedure::argnames, PLySavedArgs::args, PLyProcedure::globals, i, PLyProcedure::mcxt, MemoryContextAllocZero(), PLySavedArgs::namedargs, PLySavedArgs::nargs, and PLyProcedure::nargs.

Referenced by PLy_exec_function(), and PLy_global_args_push().

◆ PLy_global_args_pop()

static void PLy_global_args_pop ( PLyProcedure * proc )

static

Definition at line 619 of file plpy_exec.c.

 {
     Assert(proc->calldepth > 0);
     /* We only need to pop if we were already inside some active call */
     if (proc->calldepth > 1)
     {
         PLySavedArgs *ptr = proc->argstack;
  
         /* Pop the callstack */
         Assert(ptr != NULL);
         proc->argstack = ptr->next;
         proc->calldepth--;
  
         /* Restore argument values, then free ptr */
         PLy_function_restore_args(proc, ptr);
     }
     else
     {
         /* Exiting call depth 1 */
         Assert(proc->argstack == NULL);
         proc->calldepth--;
  
         /*
          * We used to delete the named arguments (but not "args") from the
          * proc's globals dict when exiting the outermost call level for a
          * function.  This seems rather pointless though: nothing can see the
          * dict until the function is called again, at which time we'll
          * overwrite those dict entries.  So don't bother with that.
          */
     }
 }

References PLyProcedure::argstack, Assert, PLyProcedure::calldepth, PLySavedArgs::next, and PLy_function_restore_args().

Referenced by PLy_exec_function().

◆ PLy_global_args_push()

static void PLy_global_args_push ( PLyProcedure * proc )

static

Definition at line 589 of file plpy_exec.c.

 {
     /* We only need to push if we are already inside some active call */
     if (proc->calldepth > 0)
     {
         PLySavedArgs *node;
  
         /* Build a struct containing current argument values */
         node = PLy_function_save_args(proc);
  
         /*
          * Push the saved argument values into the procedure's stack.  Once we
          * modify either proc->argstack or proc->calldepth, we had better
          * return without the possibility of error.
          */
         node->next = proc->argstack;
         proc->argstack = node;
     }
     proc->calldepth++;
 }

References PLyProcedure::argstack, PLyProcedure::calldepth, PLySavedArgs::next, and PLy_function_save_args().

Referenced by PLy_exec_function().

◆ PLy_modify_tuple()

static HeapTuple PLy_modify_tuple	(	PLyProcedure *	proc,
		PyObject *	pltd,
		TriggerData *	tdata,
		HeapTuple	otup
	)

static

Definition at line 898 of file plpy_exec.c.

 {
     HeapTuple   rtup;
     PyObject   *volatile plntup;
     PyObject   *volatile plkeys;
     PyObject   *volatile plval;
     Datum      *volatile modvalues;
     bool       *volatile modnulls;
     bool       *volatile modrepls;
     ErrorContextCallback plerrcontext;
  
     plerrcontext.callback = plpython_trigger_error_callback;
     plerrcontext.previous = error_context_stack;
     error_context_stack = &plerrcontext;
  
     plntup = plkeys = plval = NULL;
     modvalues = NULL;
     modnulls = NULL;
     modrepls = NULL;
  
     PG_TRY();
     {
         TupleDesc   tupdesc;
         int         nkeys,
                     i;
  
         if ((plntup = PyDict_GetItemString(pltd, "new")) == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("TD[\"new\"] deleted, cannot modify row")));
         Py_INCREF(plntup);
         if (!PyDict_Check(plntup))
             ereport(ERROR,
                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                      errmsg("TD[\"new\"] is not a dictionary")));
  
         plkeys = PyDict_Keys(plntup);
         nkeys = PyList_Size(plkeys);
  
         tupdesc = RelationGetDescr(tdata->tg_relation);
  
         modvalues = (Datum *) palloc0(tupdesc->natts * sizeof(Datum));
         modnulls = (bool *) palloc0(tupdesc->natts * sizeof(bool));
         modrepls = (bool *) palloc0(tupdesc->natts * sizeof(bool));
  
         for (i = 0; i < nkeys; i++)
         {
             PyObject   *platt;
             char       *plattstr;
             int         attn;
             PLyObToDatum *att;
  
             platt = PyList_GetItem(plkeys, i);
             if (PyUnicode_Check(platt))
                 plattstr = PLyUnicode_AsString(platt);
             else
             {
                 ereport(ERROR,
                         (errcode(ERRCODE_DATATYPE_MISMATCH),
                          errmsg("TD[\"new\"] dictionary key at ordinal position %d is not a string", i)));
                 plattstr = NULL;    /* keep compiler quiet */
             }
             attn = SPI_fnumber(tupdesc, plattstr);
             if (attn == SPI_ERROR_NOATTRIBUTE)
                 ereport(ERROR,
                         (errcode(ERRCODE_UNDEFINED_COLUMN),
                          errmsg("key \"%s\" found in TD[\"new\"] does not exist as a column in the triggering row",
                                 plattstr)));
             if (attn <= 0)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("cannot set system attribute \"%s\"",
                                 plattstr)));
             if (TupleDescAttr(tupdesc, attn - 1)->attgenerated)
                 ereport(ERROR,
                         (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
                          errmsg("cannot set generated column \"%s\"",
                                 plattstr)));
  
             plval = PyDict_GetItem(plntup, platt);
             if (plval == NULL)
                 elog(FATAL, "Python interpreter is probably corrupted");
  
             Py_INCREF(plval);
  
             /* We assume proc->result is set up to convert tuples properly */
             att = &proc->result.u.tuple.atts[attn - 1];
  
             modvalues[attn - 1] = PLy_output_convert(att,
                                                      plval,
                                                      &modnulls[attn - 1]);
             modrepls[attn - 1] = true;
  
             Py_DECREF(plval);
             plval = NULL;
         }
  
         rtup = heap_modify_tuple(otup, tupdesc, modvalues, modnulls, modrepls);
     }
     PG_CATCH();
     {
         Py_XDECREF(plntup);
         Py_XDECREF(plkeys);
         Py_XDECREF(plval);
  
         if (modvalues)
             pfree(modvalues);
         if (modnulls)
             pfree(modnulls);
         if (modrepls)
             pfree(modrepls);
  
         PG_RE_THROW();
     }
     PG_END_TRY();
  
     Py_DECREF(plntup);
     Py_DECREF(plkeys);
  
     pfree(modvalues);
     pfree(modnulls);
     pfree(modrepls);
  
     error_context_stack = plerrcontext.previous;
  
     return rtup;
 }

References PLyObToTuple::atts, ErrorContextCallback::callback, elog, ereport, errcode(), errmsg(), ERROR, error_context_stack, FATAL, heap_modify_tuple(), i, TupleDescData::natts, palloc0(), pfree(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, plpython_trigger_error_callback(), PLy_output_convert(), PLyUnicode_AsString(), ErrorContextCallback::previous, RelationGetDescr, PLyProcedure::result, SPI_ERROR_NOATTRIBUTE, SPI_fnumber(), TriggerData::tg_relation, PLyObToDatum::tuple, TupleDescAttr, and PLyObToDatum::u.

Referenced by PLy_exec_trigger().

◆ PLy_procedure_call()

static PyObject * PLy_procedure_call	(	PLyProcedure *	proc,
		const char *	kargs,
		PyObject *	vargs
	)

static

Definition at line 1038 of file plpy_exec.c.

 {
     PyObject   *rv = NULL;
     int volatile save_subxact_level = list_length(explicit_subtransactions);
  
     PyDict_SetItemString(proc->globals, kargs, vargs);
  
     PG_TRY();
     {
 #if PY_VERSION_HEX >= 0x03020000
         rv = PyEval_EvalCode(proc->code,
                              proc->globals, proc->globals);
 #else
         rv = PyEval_EvalCode((PyCodeObject *) proc->code,
                              proc->globals, proc->globals);
 #endif
  
         /*
          * Since plpy will only let you close subtransactions that you
          * started, you cannot *unnest* subtransactions, only *nest* them
          * without closing.
          */
         Assert(list_length(explicit_subtransactions) >= save_subxact_level);
     }
     PG_FINALLY();
     {
         PLy_abort_open_subtransactions(save_subxact_level);
     }
     PG_END_TRY();
  
     /* If the Python code returned an error, propagate it */
     if (rv == NULL)
         PLy_elog(ERROR, NULL);
  
     return rv;
 }

References Assert, PLyProcedure::code, ERROR, explicit_subtransactions, PLyProcedure::globals, list_length(), PG_END_TRY, PG_FINALLY, PG_TRY, PLy_abort_open_subtransactions(), and PLy_elog.

Referenced by PLy_exec_function(), and PLy_exec_trigger().

◆ PLy_trigger_build_args()

static PyObject * PLy_trigger_build_args	(	FunctionCallInfo	fcinfo,
		PLyProcedure *	proc,
		HeapTuple *	rv
	)

static

Definition at line 681 of file plpy_exec.c.

 {
     TriggerData *tdata = (TriggerData *) fcinfo->context;
     TupleDesc   rel_descr = RelationGetDescr(tdata->tg_relation);
     PyObject   *pltname,
                *pltevent,
                *pltwhen,
                *pltlevel,
                *pltrelid,
                *plttablename,
                *plttableschema,
                *pltargs,
                *pytnew,
                *pytold,
                *pltdata;
     char       *stroid;
  
     /*
      * Make any Py*_New() calls before the PG_TRY block so that we can quickly
      * return NULL on failure.  We can't return within the PG_TRY block, else
      * we'd miss unwinding the exception stack.
      */
     pltdata = PyDict_New();
     if (!pltdata)
         return NULL;
  
     if (tdata->tg_trigger->tgnargs)
     {
         pltargs = PyList_New(tdata->tg_trigger->tgnargs);
         if (!pltargs)
         {
             Py_DECREF(pltdata);
             return NULL;
         }
     }
     else
     {
         Py_INCREF(Py_None);
         pltargs = Py_None;
     }
  
     PG_TRY();
     {
         pltname = PLyUnicode_FromString(tdata->tg_trigger->tgname);
         PyDict_SetItemString(pltdata, "name", pltname);
         Py_DECREF(pltname);
  
         stroid = DatumGetCString(DirectFunctionCall1(oidout,
                                                      ObjectIdGetDatum(tdata->tg_relation->rd_id)));
         pltrelid = PLyUnicode_FromString(stroid);
         PyDict_SetItemString(pltdata, "relid", pltrelid);
         Py_DECREF(pltrelid);
         pfree(stroid);
  
         stroid = SPI_getrelname(tdata->tg_relation);
         plttablename = PLyUnicode_FromString(stroid);
         PyDict_SetItemString(pltdata, "table_name", plttablename);
         Py_DECREF(plttablename);
         pfree(stroid);
  
         stroid = SPI_getnspname(tdata->tg_relation);
         plttableschema = PLyUnicode_FromString(stroid);
         PyDict_SetItemString(pltdata, "table_schema", plttableschema);
         Py_DECREF(plttableschema);
         pfree(stroid);
  
         if (TRIGGER_FIRED_BEFORE(tdata->tg_event))
             pltwhen = PLyUnicode_FromString("BEFORE");
         else if (TRIGGER_FIRED_AFTER(tdata->tg_event))
             pltwhen = PLyUnicode_FromString("AFTER");
         else if (TRIGGER_FIRED_INSTEAD(tdata->tg_event))
             pltwhen = PLyUnicode_FromString("INSTEAD OF");
         else
         {
             elog(ERROR, "unrecognized WHEN tg_event: %u", tdata->tg_event);
             pltwhen = NULL;     /* keep compiler quiet */
         }
         PyDict_SetItemString(pltdata, "when", pltwhen);
         Py_DECREF(pltwhen);
  
         if (TRIGGER_FIRED_FOR_ROW(tdata->tg_event))
         {
             pltlevel = PLyUnicode_FromString("ROW");
             PyDict_SetItemString(pltdata, "level", pltlevel);
             Py_DECREF(pltlevel);
  
             /*
              * Note: In BEFORE trigger, stored generated columns are not
              * computed yet, so don't make them accessible in NEW row.
              */
  
             if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event))
             {
                 pltevent = PLyUnicode_FromString("INSERT");
  
                 PyDict_SetItemString(pltdata, "old", Py_None);
                 pytnew = PLy_input_from_tuple(&proc->result_in,
                                               tdata->tg_trigtuple,
                                               rel_descr,
                                               !TRIGGER_FIRED_BEFORE(tdata->tg_event));
                 PyDict_SetItemString(pltdata, "new", pytnew);
                 Py_DECREF(pytnew);
                 *rv = tdata->tg_trigtuple;
             }
             else if (TRIGGER_FIRED_BY_DELETE(tdata->tg_event))
             {
                 pltevent = PLyUnicode_FromString("DELETE");
  
                 PyDict_SetItemString(pltdata, "new", Py_None);
                 pytold = PLy_input_from_tuple(&proc->result_in,
                                               tdata->tg_trigtuple,
                                               rel_descr,
                                               true);
                 PyDict_SetItemString(pltdata, "old", pytold);
                 Py_DECREF(pytold);
                 *rv = tdata->tg_trigtuple;
             }
             else if (TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
             {
                 pltevent = PLyUnicode_FromString("UPDATE");
  
                 pytnew = PLy_input_from_tuple(&proc->result_in,
                                               tdata->tg_newtuple,
                                               rel_descr,
                                               !TRIGGER_FIRED_BEFORE(tdata->tg_event));
                 PyDict_SetItemString(pltdata, "new", pytnew);
                 Py_DECREF(pytnew);
                 pytold = PLy_input_from_tuple(&proc->result_in,
                                               tdata->tg_trigtuple,
                                               rel_descr,
                                               true);
                 PyDict_SetItemString(pltdata, "old", pytold);
                 Py_DECREF(pytold);
                 *rv = tdata->tg_newtuple;
             }
             else
             {
                 elog(ERROR, "unrecognized OP tg_event: %u", tdata->tg_event);
                 pltevent = NULL;    /* keep compiler quiet */
             }
  
             PyDict_SetItemString(pltdata, "event", pltevent);
             Py_DECREF(pltevent);
         }
         else if (TRIGGER_FIRED_FOR_STATEMENT(tdata->tg_event))
         {
             pltlevel = PLyUnicode_FromString("STATEMENT");
             PyDict_SetItemString(pltdata, "level", pltlevel);
             Py_DECREF(pltlevel);
  
             PyDict_SetItemString(pltdata, "old", Py_None);
             PyDict_SetItemString(pltdata, "new", Py_None);
             *rv = NULL;
  
             if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event))
                 pltevent = PLyUnicode_FromString("INSERT");
             else if (TRIGGER_FIRED_BY_DELETE(tdata->tg_event))
                 pltevent = PLyUnicode_FromString("DELETE");
             else if (TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
                 pltevent = PLyUnicode_FromString("UPDATE");
             else if (TRIGGER_FIRED_BY_TRUNCATE(tdata->tg_event))
                 pltevent = PLyUnicode_FromString("TRUNCATE");
             else
             {
                 elog(ERROR, "unrecognized OP tg_event: %u", tdata->tg_event);
                 pltevent = NULL;    /* keep compiler quiet */
             }
  
             PyDict_SetItemString(pltdata, "event", pltevent);
             Py_DECREF(pltevent);
         }
         else
             elog(ERROR, "unrecognized LEVEL tg_event: %u", tdata->tg_event);
  
         if (tdata->tg_trigger->tgnargs)
         {
             /*
              * all strings...
              */
             int         i;
             PyObject   *pltarg;
  
             /* pltargs should have been allocated before the PG_TRY block. */
             Assert(pltargs && pltargs != Py_None);
  
             for (i = 0; i < tdata->tg_trigger->tgnargs; i++)
             {
                 pltarg = PLyUnicode_FromString(tdata->tg_trigger->tgargs[i]);
  
                 /*
                  * stolen, don't Py_DECREF
                  */
                 PyList_SetItem(pltargs, i, pltarg);
             }
         }
         else
         {
             Assert(pltargs == Py_None);
         }
         PyDict_SetItemString(pltdata, "args", pltargs);
         Py_DECREF(pltargs);
     }
     PG_CATCH();
     {
         Py_XDECREF(pltargs);
         Py_XDECREF(pltdata);
         PG_RE_THROW();
     }
     PG_END_TRY();
  
     return pltdata;
 }

References Assert, FunctionCallInfoBaseData::context, DatumGetCString(), DirectFunctionCall1, elog, ERROR, i, ObjectIdGetDatum(), oidout(), pfree(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PLy_input_from_tuple(), PLyUnicode_FromString(), RelationData::rd_id, RelationGetDescr, PLyProcedure::result_in, SPI_getnspname(), SPI_getrelname(), TriggerData::tg_event, TriggerData::tg_newtuple, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigtuple, Trigger::tgargs, Trigger::tgname, Trigger::tgnargs, TRIGGER_FIRED_AFTER, TRIGGER_FIRED_BEFORE, TRIGGER_FIRED_BY_DELETE, TRIGGER_FIRED_BY_INSERT, TRIGGER_FIRED_BY_TRUNCATE, TRIGGER_FIRED_BY_UPDATE, TRIGGER_FIRED_FOR_ROW, TRIGGER_FIRED_FOR_STATEMENT, and TRIGGER_FIRED_INSTEAD.

Referenced by PLy_exec_trigger().

Data Structures

Typedefs

Functions

Typedef Documentation

◆ PLySRFState

Function Documentation

◆ plpython_return_error_callback()

◆ plpython_srf_cleanup_callback()

◆ plpython_trigger_error_callback()

◆ PLy_abort_open_subtransactions()

◆ PLy_exec_function()

◆ PLy_exec_trigger()

◆ PLy_function_build_args()

◆ PLy_function_drop_args()

◆ PLy_function_restore_args()

◆ PLy_function_save_args()

◆ PLy_global_args_pop()

◆ PLy_global_args_push()

◆ PLy_modify_tuple()

◆ PLy_procedure_call()

◆ PLy_trigger_build_args()