PostgreSQL Source Code  git master
plpy_exec.c File Reference
#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:

Go to the source code of this file.

Data Structures

struct  PLySRFState
 

Typedefs

typedef struct PLySRFState PLySRFState
 

Functions

static PyObject * PLy_function_build_args (FunctionCallInfo fcinfo, PLyProcedure *proc)
 
static PLySavedArgsPLy_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 670 of file plpy_exec.c.

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

Referenced by PLy_exec_function().

671 {
673 
674  if (exec_ctx->curr_proc &&
675  !exec_ctx->curr_proc->is_procedure)
676  errcontext("while creating return value");
677 }
PLyExecutionContext * PLy_current_execution_context(void)
Definition: plpy_main.c:410
PLyProcedure * curr_proc
Definition: plpy_main.h:20
#define errcontext
Definition: elog.h:183

◆ plpython_srf_cleanup_callback()

static void plpython_srf_cleanup_callback ( void *  arg)
static

Definition at line 656 of file plpy_exec.c.

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

Referenced by PLy_exec_function().

657 {
658  PLySRFState *srfstate = (PLySRFState *) arg;
659 
660  /* Release refcount on the iter, if we still have one */
661  Py_XDECREF(srfstate->iter);
662  srfstate->iter = NULL;
663  /* And drop any saved args; we won't need them */
664  if (srfstate->savedargs)
666  srfstate->savedargs = NULL;
667 }
static void PLy_function_drop_args(PLySavedArgs *savedargs)
Definition: plpy_exec.c:560
void * arg
PyObject * iter
Definition: plpy_exec.c:29
PLySavedArgs * savedargs
Definition: plpy_exec.c:30

◆ plpython_trigger_error_callback()

static void plpython_trigger_error_callback ( void *  arg)
static

Definition at line 1012 of file plpy_exec.c.

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

Referenced by PLy_modify_tuple().

1013 {
1015 
1016  if (exec_ctx->curr_proc)
1017  errcontext("while modifying trigger row");
1018 }
PLyExecutionContext * PLy_current_execution_context(void)
Definition: plpy_main.c:410
PLyProcedure * curr_proc
Definition: plpy_main.h:20
#define errcontext
Definition: elog.h:183

◆ PLy_abort_open_subtransactions()

static void PLy_abort_open_subtransactions ( int  save_subxact_level)
static

Definition at line 1064 of file plpy_exec.c.

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

1065 {
1066  Assert(save_subxact_level >= 0);
1067 
1068  while (list_length(explicit_subtransactions) > save_subxact_level)
1069  {
1070  PLySubtransactionData *subtransactiondata;
1071 
1073 
1074  ereport(WARNING,
1075  (errmsg("forcibly aborting a subtransaction that has not been exited")));
1076 
1078 
1079  subtransactiondata = (PLySubtransactionData *) linitial(explicit_subtransactions);
1081 
1082  MemoryContextSwitchTo(subtransactiondata->oldcontext);
1083  CurrentResourceOwner = subtransactiondata->oldowner;
1084  pfree(subtransactiondata);
1085  }
1086 }
#define NIL
Definition: pg_list.h:65
ResourceOwner CurrentResourceOwner
Definition: resowner.c:142
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
void pfree(void *pointer)
Definition: mcxt.c:1056
#define linitial(l)
Definition: pg_list.h:195
void RollbackAndReleaseCurrentSubTransaction(void)
Definition: xact.c:4464
List * explicit_subtransactions
#define ereport(elevel, rest)
Definition: elog.h:141
#define WARNING
Definition: elog.h:40
#define Assert(condition)
Definition: c.h:739
static int list_length(const List *l)
Definition: pg_list.h:169
int errmsg(const char *fmt,...)
Definition: elog.c:822
List * list_delete_first(List *list)
Definition: list.c:861

◆ PLy_exec_function()

Datum PLy_exec_function ( FunctionCallInfo  fcinfo,
PLyProcedure proc 
)

Definition at line 55 of file plpy_exec.c.

References ReturnSetInfo::allowedModes, MemoryContextCallback::arg, Assert, PLySRFState::callback, ErrorContextCallback::callback, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, error_context_stack, MemoryContextCallback::func, 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 plpython_call_handler(), and plpython_inline_handler().

56 {
57  bool is_setof = proc->is_setof;
58  Datum rv;
59  PyObject *volatile plargs = NULL;
60  PyObject *volatile plrv = NULL;
61  FuncCallContext *volatile funcctx = NULL;
62  PLySRFState *volatile srfstate = NULL;
63  ErrorContextCallback plerrcontext;
64 
65  /*
66  * If the function is called recursively, we must push outer-level
67  * arguments into the stack. This must be immediately before the PG_TRY
68  * to ensure that the corresponding pop happens.
69  */
71 
72  PG_TRY();
73  {
74  if (is_setof)
75  {
76  /* First Call setup */
77  if (SRF_IS_FIRSTCALL())
78  {
79  funcctx = SRF_FIRSTCALL_INIT();
80  srfstate = (PLySRFState *)
82  sizeof(PLySRFState));
83  /* Immediately register cleanup callback */
85  srfstate->callback.arg = (void *) srfstate;
87  &srfstate->callback);
88  funcctx->user_fctx = (void *) srfstate;
89  }
90  /* Every call setup */
91  funcctx = SRF_PERCALL_SETUP();
92  Assert(funcctx != NULL);
93  srfstate = (PLySRFState *) funcctx->user_fctx;
94  Assert(srfstate != NULL);
95  }
96 
97  if (srfstate == NULL || srfstate->iter == NULL)
98  {
99  /*
100  * Non-SETOF function or first time for SETOF function: build
101  * args, then actually execute the function.
102  */
103  plargs = PLy_function_build_args(fcinfo, proc);
104  plrv = PLy_procedure_call(proc, "args", plargs);
105  Assert(plrv != NULL);
106  }
107  else
108  {
109  /*
110  * Second or later call for a SETOF function: restore arguments in
111  * globals dict to what they were when we left off. We must do
112  * this in case multiple evaluations of the same SETOF function
113  * are interleaved. It's a bit annoying, since the iterator may
114  * not look at the arguments at all, but we have no way to know
115  * that. Fortunately this isn't terribly expensive.
116  */
117  if (srfstate->savedargs)
118  PLy_function_restore_args(proc, srfstate->savedargs);
119  srfstate->savedargs = NULL; /* deleted by restore_args */
120  }
121 
122  /*
123  * If it returns a set, call the iterator to get the next return item.
124  * We stay in the SPI context while doing this, because PyIter_Next()
125  * calls back into Python code which might contain SPI calls.
126  */
127  if (is_setof)
128  {
129  if (srfstate->iter == NULL)
130  {
131  /* first time -- do checks and setup */
132  ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
133 
134  if (!rsi || !IsA(rsi, ReturnSetInfo) ||
135  (rsi->allowedModes & SFRM_ValuePerCall) == 0)
136  {
137  ereport(ERROR,
138  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
139  errmsg("unsupported set function return mode"),
140  errdetail("PL/Python set-returning functions only support returning one value per call.")));
141  }
143 
144  /* Make iterator out of returned object */
145  srfstate->iter = PyObject_GetIter(plrv);
146 
147  Py_DECREF(plrv);
148  plrv = NULL;
149 
150  if (srfstate->iter == NULL)
151  ereport(ERROR,
152  (errcode(ERRCODE_DATATYPE_MISMATCH),
153  errmsg("returned object cannot be iterated"),
154  errdetail("PL/Python set-returning functions must return an iterable object.")));
155  }
156 
157  /* Fetch next from iterator */
158  plrv = PyIter_Next(srfstate->iter);
159  if (plrv == NULL)
160  {
161  /* Iterator is exhausted or error happened */
162  bool has_error = (PyErr_Occurred() != NULL);
163 
164  Py_DECREF(srfstate->iter);
165  srfstate->iter = NULL;
166 
167  if (has_error)
168  PLy_elog(ERROR, "error fetching next item from iterator");
169 
170  /* Pass a null through the data-returning steps below */
171  Py_INCREF(Py_None);
172  plrv = Py_None;
173  }
174  else
175  {
176  /*
177  * This won't be last call, so save argument values. We do
178  * this again each time in case the iterator is changing those
179  * values.
180  */
181  srfstate->savedargs = PLy_function_save_args(proc);
182  }
183  }
184 
185  /*
186  * Disconnect from SPI manager and then create the return values datum
187  * (if the input function does a palloc for it this must not be
188  * allocated in the SPI memory context because SPI_finish would free
189  * it).
190  */
191  if (SPI_finish() != SPI_OK_FINISH)
192  elog(ERROR, "SPI_finish failed");
193 
195  plerrcontext.previous = error_context_stack;
196  error_context_stack = &plerrcontext;
197 
198  /*
199  * For a procedure or function declared to return void, the Python
200  * return value must be None. For void-returning functions, we also
201  * treat a None return value as a special "void datum" rather than
202  * NULL (as is the case for non-void-returning functions).
203  */
204  if (proc->result.typoid == VOIDOID)
205  {
206  if (plrv != Py_None)
207  {
208  if (proc->is_procedure)
209  ereport(ERROR,
210  (errcode(ERRCODE_DATATYPE_MISMATCH),
211  errmsg("PL/Python procedure did not return None")));
212  else
213  ereport(ERROR,
214  (errcode(ERRCODE_DATATYPE_MISMATCH),
215  errmsg("PL/Python function with return type \"void\" did not return None")));
216  }
217 
218  fcinfo->isnull = false;
219  rv = (Datum) 0;
220  }
221  else if (plrv == Py_None &&
222  srfstate && srfstate->iter == NULL)
223  {
224  /*
225  * In a SETOF function, the iteration-ending null isn't a real
226  * value; don't pass it through the input function, which might
227  * complain.
228  */
229  fcinfo->isnull = true;
230  rv = (Datum) 0;
231  }
232  else
233  {
234  /* Normal conversion of result */
235  rv = PLy_output_convert(&proc->result, plrv,
236  &fcinfo->isnull);
237  }
238  }
239  PG_CATCH();
240  {
241  /* Pop old arguments from the stack if they were pushed above */
242  PLy_global_args_pop(proc);
243 
244  Py_XDECREF(plargs);
245  Py_XDECREF(plrv);
246 
247  /*
248  * If there was an error within a SRF, the iterator might not have
249  * been exhausted yet. Clear it so the next invocation of the
250  * function will start the iteration again. (This code is probably
251  * unnecessary now; plpython_srf_cleanup_callback should take care of
252  * cleanup. But it doesn't hurt anything to do it here.)
253  */
254  if (srfstate)
255  {
256  Py_XDECREF(srfstate->iter);
257  srfstate->iter = NULL;
258  /* And drop any saved args; we won't need them */
259  if (srfstate->savedargs)
261  srfstate->savedargs = NULL;
262  }
263 
264  PG_RE_THROW();
265  }
266  PG_END_TRY();
267 
268  error_context_stack = plerrcontext.previous;
269 
270  /* Pop old arguments from the stack if they were pushed above */
271  PLy_global_args_pop(proc);
272 
273  Py_XDECREF(plargs);
274  Py_DECREF(plrv);
275 
276  if (srfstate)
277  {
278  /* We're in a SRF, exit appropriately */
279  if (srfstate->iter == NULL)
280  {
281  /* Iterator exhausted, so we're done */
282  SRF_RETURN_DONE(funcctx);
283  }
284  else if (fcinfo->isnull)
285  SRF_RETURN_NEXT_NULL(funcctx);
286  else
287  SRF_RETURN_NEXT(funcctx, rv);
288  }
289 
290  /* Plain function, just return the Datum value (possibly null) */
291  return rv;
292 }
MemoryContextCallbackFunction func
Definition: palloc.h:49
#define IsA(nodeptr, _type_)
Definition: nodes.h:576
Datum PLy_output_convert(PLyObToDatum *arg, PyObject *val, bool *isnull)
Definition: plpy_typeio.c:119
static void PLy_global_args_push(PLyProcedure *proc)
Definition: plpy_exec.c:588
static void PLy_global_args_pop(PLyProcedure *proc)
Definition: plpy_exec.c:618
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:282
int SPI_finish(void)
Definition: spi.c:176
int errcode(int sqlerrcode)
Definition: elog.c:608
static void PLy_function_restore_args(PLyProcedure *proc, PLySavedArgs *savedargs)
Definition: plpy_exec.c:527
void(* callback)(void *arg)
Definition: elog.h:256
struct ErrorContextCallback * previous
Definition: elog.h:255
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:286
static PyObject * PLy_function_build_args(FunctionCallInfo fcinfo, PLyProcedure *proc)
Definition: plpy_exec.c:415
ErrorContextCallback * error_context_stack
Definition: elog.c:91
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:288
#define ERROR
Definition: elog.h:43
static void plpython_return_error_callback(void *arg)
Definition: plpy_exec.c:670
fmNodePtr resultinfo
Definition: fmgr.h:89
#define PLy_elog
static PLySavedArgs * PLy_function_save_args(PLyProcedure *proc)
Definition: plpy_exec.c:488
int errdetail(const char *fmt,...)
Definition: elog.c:955
#define SRF_RETURN_NEXT_NULL(_funcctx)
Definition: funcapi.h:297
#define ereport(elevel, rest)
Definition: elog.h:141
static void PLy_function_drop_args(PLySavedArgs *savedargs)
Definition: plpy_exec.c:560
uintptr_t Datum
Definition: postgres.h:367
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:839
int allowedModes
Definition: execnodes.h:302
SetFunctionReturnMode returnMode
Definition: execnodes.h:304
#define PG_CATCH()
Definition: elog.h:332
#define Assert(condition)
Definition: c.h:739
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:101
#define SPI_OK_FINISH
Definition: spi.h:54
#define PG_RE_THROW()
Definition: elog.h:363
PLyObToDatum result
void * user_fctx
Definition: funcapi.h:82
int errmsg(const char *fmt,...)
Definition: elog.c:822
#define elog(elevel,...)
Definition: elog.h:228
PyObject * iter
Definition: plpy_exec.c:29
void MemoryContextRegisterResetCallback(MemoryContext context, MemoryContextCallback *cb)
Definition: mcxt.c:285
PLySavedArgs * savedargs
Definition: plpy_exec.c:30
MemoryContextCallback callback
Definition: plpy_exec.c:31
#define PG_TRY()
Definition: elog.h:322
static PyObject * PLy_procedure_call(PLyProcedure *proc, const char *kargs, PyObject *vargs)
Definition: plpy_exec.c:1022
#define PG_END_TRY()
Definition: elog.h:347
static void plpython_srf_cleanup_callback(void *arg)
Definition: plpy_exec.c:656
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:306
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:284

◆ PLy_exec_trigger()

HeapTuple PLy_exec_trigger ( FunctionCallInfo  fcinfo,
PLyProcedure proc 
)

Definition at line 305 of file plpy_exec.c.

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

306 {
307  HeapTuple rv = NULL;
308  PyObject *volatile plargs = NULL;
309  PyObject *volatile plrv = NULL;
310  TriggerData *tdata;
311  TupleDesc rel_descr;
312 
313  Assert(CALLED_AS_TRIGGER(fcinfo));
314  tdata = (TriggerData *) fcinfo->context;
315 
316  /*
317  * Input/output conversion for trigger tuples. We use the result and
318  * result_in fields to store the tuple conversion info. We do this over
319  * again on each call to cover the possibility that the relation's tupdesc
320  * changed since the trigger was last called. The PLy_xxx_setup_func
321  * calls should only happen once, but PLy_input_setup_tuple and
322  * PLy_output_setup_tuple are responsible for not doing repetitive work.
323  */
324  rel_descr = RelationGetDescr(tdata->tg_relation);
325  if (proc->result.typoid != rel_descr->tdtypeid)
326  PLy_output_setup_func(&proc->result, proc->mcxt,
327  rel_descr->tdtypeid,
328  rel_descr->tdtypmod,
329  proc);
330  if (proc->result_in.typoid != rel_descr->tdtypeid)
331  PLy_input_setup_func(&proc->result_in, proc->mcxt,
332  rel_descr->tdtypeid,
333  rel_descr->tdtypmod,
334  proc);
335  PLy_output_setup_tuple(&proc->result, rel_descr, proc);
336  PLy_input_setup_tuple(&proc->result_in, rel_descr, proc);
337 
338  PG_TRY();
339  {
341 
342  rc = SPI_register_trigger_data(tdata);
343  Assert(rc >= 0);
344 
345  plargs = PLy_trigger_build_args(fcinfo, proc, &rv);
346  plrv = PLy_procedure_call(proc, "TD", plargs);
347 
348  Assert(plrv != NULL);
349 
350  /*
351  * Disconnect from SPI manager
352  */
353  if (SPI_finish() != SPI_OK_FINISH)
354  elog(ERROR, "SPI_finish failed");
355 
356  /*
357  * return of None means we're happy with the tuple
358  */
359  if (plrv != Py_None)
360  {
361  char *srv;
362 
363  if (PyString_Check(plrv))
364  srv = PyString_AsString(plrv);
365  else if (PyUnicode_Check(plrv))
366  srv = PLyUnicode_AsString(plrv);
367  else
368  {
369  ereport(ERROR,
370  (errcode(ERRCODE_DATA_EXCEPTION),
371  errmsg("unexpected return value from trigger procedure"),
372  errdetail("Expected None or a string.")));
373  srv = NULL; /* keep compiler quiet */
374  }
375 
376  if (pg_strcasecmp(srv, "SKIP") == 0)
377  rv = NULL;
378  else if (pg_strcasecmp(srv, "MODIFY") == 0)
379  {
380  TriggerData *tdata = (TriggerData *) fcinfo->context;
381 
382  if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event) ||
384  rv = PLy_modify_tuple(proc, plargs, tdata, rv);
385  else
387  (errmsg("PL/Python trigger function returned \"MODIFY\" in a DELETE trigger -- ignored")));
388  }
389  else if (pg_strcasecmp(srv, "OK") != 0)
390  {
391  /*
392  * accept "OK" as an alternative to None; otherwise, raise an
393  * error
394  */
395  ereport(ERROR,
396  (errcode(ERRCODE_DATA_EXCEPTION),
397  errmsg("unexpected return value from trigger procedure"),
398  errdetail("Expected None, \"OK\", \"SKIP\", or \"MODIFY\".")));
399  }
400  }
401  }
402  PG_FINALLY();
403  {
404  Py_XDECREF(plargs);
405  Py_XDECREF(plrv);
406  }
407  PG_END_TRY();
408 
409  return rv;
410 }
#define RelationGetDescr(relation)
Definition: rel.h:448
int SPI_finish(void)
Definition: spi.c:176
int errcode(int sqlerrcode)
Definition: elog.c:608
fmNodePtr context
Definition: fmgr.h:88
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
static HeapTuple PLy_modify_tuple(PLyProcedure *proc, PyObject *pltd, TriggerData *tdata, HeapTuple otup)
Definition: plpy_exec.c:880
char * PLyUnicode_AsString(PyObject *unicode)
Definition: plpy_util.c:89
#define ERROR
Definition: elog.h:43
int32 tdtypmod
Definition: tupdesc.h:83
MemoryContext mcxt
void PLy_input_setup_tuple(PLyDatumToOb *arg, TupleDesc desc, PLyProcedure *proc)
Definition: plpy_typeio.c:164
int errdetail(const char *fmt,...)
Definition: elog.c:955
void PLy_input_setup_func(PLyDatumToOb *arg, MemoryContext arg_mcxt, Oid typeOid, int32 typmod, PLyProcedure *proc)
Definition: plpy_typeio.c:417
#define ereport(elevel, rest)
Definition: elog.h:141
int SPI_register_trigger_data(TriggerData *tdata)
Definition: spi.c:2934
#define WARNING
Definition: elog.h:40
#define PG_FINALLY()
Definition: elog.h:339
void PLy_output_setup_tuple(PLyObToDatum *arg, TupleDesc desc, PLyProcedure *proc)
Definition: plpy_typeio.c:214
#define CALLED_AS_TRIGGER(fcinfo)
Definition: trigger.h:25
#define Assert(condition)
Definition: c.h:739
TriggerEvent tg_event
Definition: trigger.h:33
PLyDatumToOb result_in
#define SPI_OK_FINISH
Definition: spi.h:54
Oid tdtypeid
Definition: tupdesc.h:82
void PLy_output_setup_func(PLyObToDatum *arg, MemoryContext arg_mcxt, Oid typeOid, int32 typmod, PLyProcedure *proc)
Definition: plpy_typeio.c:295
PLyObToDatum result
#define TRIGGER_FIRED_BY_INSERT(event)
Definition: trigger.h:116
static PyObject * PLy_trigger_build_args(FunctionCallInfo fcinfo, PLyProcedure *proc, HeapTuple *rv)
Definition: plpy_exec.c:680
int errmsg(const char *fmt,...)
Definition: elog.c:822
#define elog(elevel,...)
Definition: elog.h:228
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:123
#define PG_TRY()
Definition: elog.h:322
#define TRIGGER_FIRED_BY_UPDATE(event)
Definition: trigger.h:122
static PyObject * PLy_procedure_call(PLyProcedure *proc, const char *kargs, PyObject *vargs)
Definition: plpy_exec.c:1022
#define PG_END_TRY()
Definition: elog.h:347
Relation tg_relation
Definition: trigger.h:34

◆ PLy_function_build_args()

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

Definition at line 415 of file plpy_exec.c.

References arg, PLyProcedure::argnames, PLyProcedure::args, FunctionCallInfoBaseData::args, generate_unaccent_rules::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().

416 {
417  PyObject *volatile arg = NULL;
418  PyObject *volatile args = NULL;
419  int i;
420 
421  PG_TRY();
422  {
423  args = PyList_New(proc->nargs);
424  if (!args)
425  return NULL;
426 
427  for (i = 0; i < proc->nargs; i++)
428  {
429  PLyDatumToOb *arginfo = &proc->args[i];
430 
431  if (fcinfo->args[i].isnull)
432  arg = NULL;
433  else
434  arg = PLy_input_convert(arginfo, fcinfo->args[i].value);
435 
436  if (arg == NULL)
437  {
438  Py_INCREF(Py_None);
439  arg = Py_None;
440  }
441 
442  if (PyList_SetItem(args, i, arg) == -1)
443  PLy_elog(ERROR, "PyList_SetItem() failed, while setting up arguments");
444 
445  if (proc->argnames && proc->argnames[i] &&
446  PyDict_SetItemString(proc->globals, proc->argnames[i], arg) == -1)
447  PLy_elog(ERROR, "PyDict_SetItemString() failed, while setting up arguments");
448  arg = NULL;
449  }
450 
451  /* Set up output conversion for functions returning RECORD */
452  if (proc->result.typoid == RECORDOID)
453  {
454  TupleDesc desc;
455 
456  if (get_call_result_type(fcinfo, NULL, &desc) != TYPEFUNC_COMPOSITE)
457  ereport(ERROR,
458  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
459  errmsg("function returning record called in context "
460  "that cannot accept type record")));
461 
462  /* cache the output conversion functions */
463  PLy_output_setup_record(&proc->result, desc, proc);
464  }
465  }
466  PG_CATCH();
467  {
468  Py_XDECREF(arg);
469  Py_XDECREF(args);
470 
471  PG_RE_THROW();
472  }
473  PG_END_TRY();
474 
475  return args;
476 }
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition: funcapi.c:196
int errcode(int sqlerrcode)
Definition: elog.c:608
PLyDatumToOb * args
char ** argnames
#define ERROR
Definition: elog.h:43
void PLy_output_setup_record(PLyObToDatum *arg, TupleDesc desc, PLyProcedure *proc)
Definition: plpy_typeio.c:260
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition: fmgr.h:95
#define PLy_elog
#define ereport(elevel, rest)
Definition: elog.h:141
Datum value
Definition: postgres.h:378
#define PG_CATCH()
Definition: elog.h:332
PyObject * PLy_input_convert(PLyDatumToOb *arg, Datum val)
Definition: plpy_typeio.c:80
#define PG_RE_THROW()
Definition: elog.h:363
PLyObToDatum result
int errmsg(const char *fmt,...)
Definition: elog.c:822
int i
void * arg
#define PG_TRY()
Definition: elog.h:322
PyObject * globals
#define PG_END_TRY()
Definition: elog.h:347

◆ PLy_function_drop_args()

static void PLy_function_drop_args ( PLySavedArgs savedargs)
static

Definition at line 560 of file plpy_exec.c.

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

Referenced by plpython_srf_cleanup_callback(), and PLy_exec_function().

561 {
562  int i;
563 
564  /* Drop references for named args */
565  for (i = 0; i < savedargs->nargs; i++)
566  {
567  Py_XDECREF(savedargs->namedargs[i]);
568  }
569 
570  /* Drop ref to the "args" object, too */
571  Py_XDECREF(savedargs->args);
572 
573  /* And free the PLySavedArgs struct */
574  pfree(savedargs);
575 }
PyObject * args
void pfree(void *pointer)
Definition: mcxt.c:1056
PyObject * namedargs[FLEXIBLE_ARRAY_MEMBER]
int i

◆ PLy_function_restore_args()

static void PLy_function_restore_args ( PLyProcedure proc,
PLySavedArgs savedargs 
)
static

Definition at line 527 of file plpy_exec.c.

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

Referenced by PLy_exec_function(), and PLy_global_args_pop().

528 {
529  /* Restore named arguments into their slots in the globals dict */
530  if (proc->argnames)
531  {
532  int i;
533 
534  for (i = 0; i < savedargs->nargs; i++)
535  {
536  if (proc->argnames[i] && savedargs->namedargs[i])
537  {
538  PyDict_SetItemString(proc->globals, proc->argnames[i],
539  savedargs->namedargs[i]);
540  Py_DECREF(savedargs->namedargs[i]);
541  }
542  }
543  }
544 
545  /* Restore the "args" object, too */
546  if (savedargs->args)
547  {
548  PyDict_SetItemString(proc->globals, "args", savedargs->args);
549  Py_DECREF(savedargs->args);
550  }
551 
552  /* And free the PLySavedArgs struct */
553  pfree(savedargs);
554 }
PyObject * args
char ** argnames
void pfree(void *pointer)
Definition: mcxt.c:1056
PyObject * namedargs[FLEXIBLE_ARRAY_MEMBER]
int i
PyObject * globals

◆ PLy_function_save_args()

static PLySavedArgs * PLy_function_save_args ( PLyProcedure proc)
static

Definition at line 488 of file plpy_exec.c.

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

Referenced by PLy_exec_function(), and PLy_global_args_push().

489 {
490  PLySavedArgs *result;
491 
492  /* saved args are always allocated in procedure's context */
493  result = (PLySavedArgs *)
495  offsetof(PLySavedArgs, namedargs) +
496  proc->nargs * sizeof(PyObject *));
497  result->nargs = proc->nargs;
498 
499  /* Fetch the "args" list */
500  result->args = PyDict_GetItemString(proc->globals, "args");
501  Py_XINCREF(result->args);
502 
503  /* Fetch all the named arguments */
504  if (proc->argnames)
505  {
506  int i;
507 
508  for (i = 0; i < result->nargs; i++)
509  {
510  if (proc->argnames[i])
511  {
512  result->namedargs[i] = PyDict_GetItemString(proc->globals,
513  proc->argnames[i]);
514  Py_XINCREF(result->namedargs[i]);
515  }
516  }
517  }
518 
519  return result;
520 }
PyObject * args
char ** argnames
MemoryContext mcxt
PyObject * namedargs[FLEXIBLE_ARRAY_MEMBER]
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:839
int i
PyObject * globals
#define offsetof(type, field)
Definition: c.h:662

◆ PLy_global_args_pop()

static void PLy_global_args_pop ( PLyProcedure proc)
static

Definition at line 618 of file plpy_exec.c.

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

Referenced by PLy_exec_function().

619 {
620  Assert(proc->calldepth > 0);
621  /* We only need to pop if we were already inside some active call */
622  if (proc->calldepth > 1)
623  {
624  PLySavedArgs *ptr = proc->argstack;
625 
626  /* Pop the callstack */
627  Assert(ptr != NULL);
628  proc->argstack = ptr->next;
629  proc->calldepth--;
630 
631  /* Restore argument values, then free ptr */
632  PLy_function_restore_args(proc, ptr);
633  }
634  else
635  {
636  /* Exiting call depth 1 */
637  Assert(proc->argstack == NULL);
638  proc->calldepth--;
639 
640  /*
641  * We used to delete the named arguments (but not "args") from the
642  * proc's globals dict when exiting the outermost call level for a
643  * function. This seems rather pointless though: nothing can see the
644  * dict until the function is called again, at which time we'll
645  * overwrite those dict entries. So don't bother with that.
646  */
647  }
648 }
struct PLySavedArgs * next
static void PLy_function_restore_args(PLyProcedure *proc, PLySavedArgs *savedargs)
Definition: plpy_exec.c:527
#define Assert(condition)
Definition: c.h:739
PLySavedArgs * argstack

◆ PLy_global_args_push()

static void PLy_global_args_push ( PLyProcedure proc)
static

Definition at line 588 of file plpy_exec.c.

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

Referenced by PLy_exec_function().

589 {
590  /* We only need to push if we are already inside some active call */
591  if (proc->calldepth > 0)
592  {
593  PLySavedArgs *node;
594 
595  /* Build a struct containing current argument values */
596  node = PLy_function_save_args(proc);
597 
598  /*
599  * Push the saved argument values into the procedure's stack. Once we
600  * modify either proc->argstack or proc->calldepth, we had better
601  * return without the possibility of error.
602  */
603  node->next = proc->argstack;
604  proc->argstack = node;
605  }
606  proc->calldepth++;
607 }
struct PLySavedArgs * next
static PLySavedArgs * PLy_function_save_args(PLyProcedure *proc)
Definition: plpy_exec.c:488
PLySavedArgs * argstack

◆ PLy_modify_tuple()

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

Definition at line 880 of file plpy_exec.c.

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

882 {
883  HeapTuple rtup;
884  PyObject *volatile plntup;
885  PyObject *volatile plkeys;
886  PyObject *volatile plval;
887  Datum *volatile modvalues;
888  bool *volatile modnulls;
889  bool *volatile modrepls;
890  ErrorContextCallback plerrcontext;
891 
893  plerrcontext.previous = error_context_stack;
894  error_context_stack = &plerrcontext;
895 
896  plntup = plkeys = plval = NULL;
897  modvalues = NULL;
898  modnulls = NULL;
899  modrepls = NULL;
900 
901  PG_TRY();
902  {
903  TupleDesc tupdesc;
904  int nkeys,
905  i;
906 
907  if ((plntup = PyDict_GetItemString(pltd, "new")) == NULL)
908  ereport(ERROR,
909  (errcode(ERRCODE_UNDEFINED_OBJECT),
910  errmsg("TD[\"new\"] deleted, cannot modify row")));
911  Py_INCREF(plntup);
912  if (!PyDict_Check(plntup))
913  ereport(ERROR,
914  (errcode(ERRCODE_DATATYPE_MISMATCH),
915  errmsg("TD[\"new\"] is not a dictionary")));
916 
917  plkeys = PyDict_Keys(plntup);
918  nkeys = PyList_Size(plkeys);
919 
920  tupdesc = RelationGetDescr(tdata->tg_relation);
921 
922  modvalues = (Datum *) palloc0(tupdesc->natts * sizeof(Datum));
923  modnulls = (bool *) palloc0(tupdesc->natts * sizeof(bool));
924  modrepls = (bool *) palloc0(tupdesc->natts * sizeof(bool));
925 
926  for (i = 0; i < nkeys; i++)
927  {
928  PyObject *platt;
929  char *plattstr;
930  int attn;
931  PLyObToDatum *att;
932 
933  platt = PyList_GetItem(plkeys, i);
934  if (PyString_Check(platt))
935  plattstr = PyString_AsString(platt);
936  else if (PyUnicode_Check(platt))
937  plattstr = PLyUnicode_AsString(platt);
938  else
939  {
940  ereport(ERROR,
941  (errcode(ERRCODE_DATATYPE_MISMATCH),
942  errmsg("TD[\"new\"] dictionary key at ordinal position %d is not a string", i)));
943  plattstr = NULL; /* keep compiler quiet */
944  }
945  attn = SPI_fnumber(tupdesc, plattstr);
946  if (attn == SPI_ERROR_NOATTRIBUTE)
947  ereport(ERROR,
948  (errcode(ERRCODE_UNDEFINED_COLUMN),
949  errmsg("key \"%s\" found in TD[\"new\"] does not exist as a column in the triggering row",
950  plattstr)));
951  if (attn <= 0)
952  ereport(ERROR,
953  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
954  errmsg("cannot set system attribute \"%s\"",
955  plattstr)));
956  if (TupleDescAttr(tupdesc, attn - 1)->attgenerated)
957  ereport(ERROR,
958  (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
959  errmsg("cannot set generated column \"%s\"",
960  plattstr)));
961 
962  plval = PyDict_GetItem(plntup, platt);
963  if (plval == NULL)
964  elog(FATAL, "Python interpreter is probably corrupted");
965 
966  Py_INCREF(plval);
967 
968  /* We assume proc->result is set up to convert tuples properly */
969  att = &proc->result.u.tuple.atts[attn - 1];
970 
971  modvalues[attn - 1] = PLy_output_convert(att,
972  plval,
973  &modnulls[attn - 1]);
974  modrepls[attn - 1] = true;
975 
976  Py_DECREF(plval);
977  plval = NULL;
978  }
979 
980  rtup = heap_modify_tuple(otup, tupdesc, modvalues, modnulls, modrepls);
981  }
982  PG_CATCH();
983  {
984  Py_XDECREF(plntup);
985  Py_XDECREF(plkeys);
986  Py_XDECREF(plval);
987 
988  if (modvalues)
989  pfree(modvalues);
990  if (modnulls)
991  pfree(modnulls);
992  if (modrepls)
993  pfree(modrepls);
994 
995  PG_RE_THROW();
996  }
997  PG_END_TRY();
998 
999  Py_DECREF(plntup);
1000  Py_DECREF(plkeys);
1001 
1002  pfree(modvalues);
1003  pfree(modnulls);
1004  pfree(modrepls);
1005 
1006  error_context_stack = plerrcontext.previous;
1007 
1008  return rtup;
1009 }
int SPI_fnumber(TupleDesc tupdesc, const char *fname)
Definition: spi.c:951
Datum PLy_output_convert(PLyObToDatum *arg, PyObject *val, bool *isnull)
Definition: plpy_typeio.c:119
#define RelationGetDescr(relation)
Definition: rel.h:448
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
int errcode(int sqlerrcode)
Definition: elog.c:608
void(* callback)(void *arg)
Definition: elog.h:256
struct ErrorContextCallback * previous
Definition: elog.h:255
char * PLyUnicode_AsString(PyObject *unicode)
Definition: plpy_util.c:89
ErrorContextCallback * error_context_stack
Definition: elog.c:91
void pfree(void *pointer)
Definition: mcxt.c:1056
#define ERROR
Definition: elog.h:43
#define FATAL
Definition: elog.h:52
#define SPI_ERROR_NOATTRIBUTE
Definition: spi.h:47
#define ereport(elevel, rest)
Definition: elog.h:141
void * palloc0(Size size)
Definition: mcxt.c:980
uintptr_t Datum
Definition: postgres.h:367
#define PG_CATCH()
Definition: elog.h:332
static void plpython_trigger_error_callback(void *arg)
Definition: plpy_exec.c:1012
#define PG_RE_THROW()
Definition: elog.h:363
PLyObToDatum result
PLyObToTuple tuple
Definition: plpy_typeio.h:143
int errmsg(const char *fmt,...)
Definition: elog.c:822
#define elog(elevel,...)
Definition: elog.h:228
int i
PLyObToDatum * atts
Definition: plpy_typeio.h:113
#define PG_TRY()
Definition: elog.h:322
HeapTuple heap_modify_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *replValues, bool *replIsnull, bool *doReplace)
Definition: heaptuple.c:1113
#define PG_END_TRY()
Definition: elog.h:347
union PLyObToDatum::@166 u
Relation tg_relation
Definition: trigger.h:34

◆ PLy_procedure_call()

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

Definition at line 1022 of file plpy_exec.c.

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

1023 {
1024  PyObject *rv = NULL;
1025  int volatile save_subxact_level = list_length(explicit_subtransactions);
1026 
1027  PyDict_SetItemString(proc->globals, kargs, vargs);
1028 
1029  PG_TRY();
1030  {
1031 #if PY_VERSION_HEX >= 0x03020000
1032  rv = PyEval_EvalCode(proc->code,
1033  proc->globals, proc->globals);
1034 #else
1035  rv = PyEval_EvalCode((PyCodeObject *) proc->code,
1036  proc->globals, proc->globals);
1037 #endif
1038 
1039  /*
1040  * Since plpy will only let you close subtransactions that you
1041  * started, you cannot *unnest* subtransactions, only *nest* them
1042  * without closing.
1043  */
1044  Assert(list_length(explicit_subtransactions) >= save_subxact_level);
1045  }
1046  PG_FINALLY();
1047  {
1048  PLy_abort_open_subtransactions(save_subxact_level);
1049  }
1050  PG_END_TRY();
1051 
1052  /* If the Python code returned an error, propagate it */
1053  if (rv == NULL)
1054  PLy_elog(ERROR, NULL);
1055 
1056  return rv;
1057 }
#define ERROR
Definition: elog.h:43
#define PLy_elog
List * explicit_subtransactions
#define PG_FINALLY()
Definition: elog.h:339
PyObject * code
static void PLy_abort_open_subtransactions(int save_subxact_level)
Definition: plpy_exec.c:1064
#define Assert(condition)
Definition: c.h:739
static int list_length(const List *l)
Definition: pg_list.h:169
#define PG_TRY()
Definition: elog.h:322
PyObject * globals
#define PG_END_TRY()
Definition: elog.h:347

◆ PLy_trigger_build_args()

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

Definition at line 680 of file plpy_exec.c.

References FunctionCallInfoBaseData::context, DatumGetCString, DirectFunctionCall1, elog, ERROR, i, ObjectIdGetDatum, oidout(), pfree(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PLy_input_from_tuple(), 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().

681 {
682  TriggerData *tdata = (TriggerData *) fcinfo->context;
683  TupleDesc rel_descr = RelationGetDescr(tdata->tg_relation);
684  PyObject *pltname,
685  *pltevent,
686  *pltwhen,
687  *pltlevel,
688  *pltrelid,
689  *plttablename,
690  *plttableschema;
691  PyObject *pltargs,
692  *pytnew,
693  *pytold;
694  PyObject *volatile pltdata = NULL;
695  char *stroid;
696 
697  PG_TRY();
698  {
699  pltdata = PyDict_New();
700  if (!pltdata)
701  return NULL;
702 
703  pltname = PyString_FromString(tdata->tg_trigger->tgname);
704  PyDict_SetItemString(pltdata, "name", pltname);
705  Py_DECREF(pltname);
706 
709  pltrelid = PyString_FromString(stroid);
710  PyDict_SetItemString(pltdata, "relid", pltrelid);
711  Py_DECREF(pltrelid);
712  pfree(stroid);
713 
714  stroid = SPI_getrelname(tdata->tg_relation);
715  plttablename = PyString_FromString(stroid);
716  PyDict_SetItemString(pltdata, "table_name", plttablename);
717  Py_DECREF(plttablename);
718  pfree(stroid);
719 
720  stroid = SPI_getnspname(tdata->tg_relation);
721  plttableschema = PyString_FromString(stroid);
722  PyDict_SetItemString(pltdata, "table_schema", plttableschema);
723  Py_DECREF(plttableschema);
724  pfree(stroid);
725 
726  if (TRIGGER_FIRED_BEFORE(tdata->tg_event))
727  pltwhen = PyString_FromString("BEFORE");
728  else if (TRIGGER_FIRED_AFTER(tdata->tg_event))
729  pltwhen = PyString_FromString("AFTER");
730  else if (TRIGGER_FIRED_INSTEAD(tdata->tg_event))
731  pltwhen = PyString_FromString("INSTEAD OF");
732  else
733  {
734  elog(ERROR, "unrecognized WHEN tg_event: %u", tdata->tg_event);
735  pltwhen = NULL; /* keep compiler quiet */
736  }
737  PyDict_SetItemString(pltdata, "when", pltwhen);
738  Py_DECREF(pltwhen);
739 
740  if (TRIGGER_FIRED_FOR_ROW(tdata->tg_event))
741  {
742  pltlevel = PyString_FromString("ROW");
743  PyDict_SetItemString(pltdata, "level", pltlevel);
744  Py_DECREF(pltlevel);
745 
746  /*
747  * Note: In BEFORE trigger, stored generated columns are not
748  * computed yet, so don't make them accessible in NEW row.
749  */
750 
751  if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event))
752  {
753  pltevent = PyString_FromString("INSERT");
754 
755  PyDict_SetItemString(pltdata, "old", Py_None);
756  pytnew = PLy_input_from_tuple(&proc->result_in,
757  tdata->tg_trigtuple,
758  rel_descr,
759  !TRIGGER_FIRED_BEFORE(tdata->tg_event));
760  PyDict_SetItemString(pltdata, "new", pytnew);
761  Py_DECREF(pytnew);
762  *rv = tdata->tg_trigtuple;
763  }
764  else if (TRIGGER_FIRED_BY_DELETE(tdata->tg_event))
765  {
766  pltevent = PyString_FromString("DELETE");
767 
768  PyDict_SetItemString(pltdata, "new", Py_None);
769  pytold = PLy_input_from_tuple(&proc->result_in,
770  tdata->tg_trigtuple,
771  rel_descr,
772  true);
773  PyDict_SetItemString(pltdata, "old", pytold);
774  Py_DECREF(pytold);
775  *rv = tdata->tg_trigtuple;
776  }
777  else if (TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
778  {
779  pltevent = PyString_FromString("UPDATE");
780 
781  pytnew = PLy_input_from_tuple(&proc->result_in,
782  tdata->tg_newtuple,
783  rel_descr,
784  !TRIGGER_FIRED_BEFORE(tdata->tg_event));
785  PyDict_SetItemString(pltdata, "new", pytnew);
786  Py_DECREF(pytnew);
787  pytold = PLy_input_from_tuple(&proc->result_in,
788  tdata->tg_trigtuple,
789  rel_descr,
790  true);
791  PyDict_SetItemString(pltdata, "old", pytold);
792  Py_DECREF(pytold);
793  *rv = tdata->tg_newtuple;
794  }
795  else
796  {
797  elog(ERROR, "unrecognized OP tg_event: %u", tdata->tg_event);
798  pltevent = NULL; /* keep compiler quiet */
799  }
800 
801  PyDict_SetItemString(pltdata, "event", pltevent);
802  Py_DECREF(pltevent);
803  }
804  else if (TRIGGER_FIRED_FOR_STATEMENT(tdata->tg_event))
805  {
806  pltlevel = PyString_FromString("STATEMENT");
807  PyDict_SetItemString(pltdata, "level", pltlevel);
808  Py_DECREF(pltlevel);
809 
810  PyDict_SetItemString(pltdata, "old", Py_None);
811  PyDict_SetItemString(pltdata, "new", Py_None);
812  *rv = NULL;
813 
814  if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event))
815  pltevent = PyString_FromString("INSERT");
816  else if (TRIGGER_FIRED_BY_DELETE(tdata->tg_event))
817  pltevent = PyString_FromString("DELETE");
818  else if (TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
819  pltevent = PyString_FromString("UPDATE");
820  else if (TRIGGER_FIRED_BY_TRUNCATE(tdata->tg_event))
821  pltevent = PyString_FromString("TRUNCATE");
822  else
823  {
824  elog(ERROR, "unrecognized OP tg_event: %u", tdata->tg_event);
825  pltevent = NULL; /* keep compiler quiet */
826  }
827 
828  PyDict_SetItemString(pltdata, "event", pltevent);
829  Py_DECREF(pltevent);
830  }
831  else
832  elog(ERROR, "unrecognized LEVEL tg_event: %u", tdata->tg_event);
833 
834  if (tdata->tg_trigger->tgnargs)
835  {
836  /*
837  * all strings...
838  */
839  int i;
840  PyObject *pltarg;
841 
842  pltargs = PyList_New(tdata->tg_trigger->tgnargs);
843  if (!pltargs)
844  {
845  Py_DECREF(pltdata);
846  return NULL;
847  }
848  for (i = 0; i < tdata->tg_trigger->tgnargs; i++)
849  {
850  pltarg = PyString_FromString(tdata->tg_trigger->tgargs[i]);
851 
852  /*
853  * stolen, don't Py_DECREF
854  */
855  PyList_SetItem(pltargs, i, pltarg);
856  }
857  }
858  else
859  {
860  Py_INCREF(Py_None);
861  pltargs = Py_None;
862  }
863  PyDict_SetItemString(pltdata, "args", pltargs);
864  Py_DECREF(pltargs);
865  }
866  PG_CATCH();
867  {
868  Py_XDECREF(pltdata);
869  PG_RE_THROW();
870  }
871  PG_END_TRY();
872 
873  return pltdata;
874 }
#define RelationGetDescr(relation)
Definition: rel.h:448
fmNodePtr context
Definition: fmgr.h:88
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:615
#define TRIGGER_FIRED_AFTER(event)
Definition: trigger.h:137
Datum oidout(PG_FUNCTION_ARGS)
Definition: oid.c:127
#define TRIGGER_FIRED_FOR_STATEMENT(event)
Definition: trigger.h:131
HeapTuple tg_trigtuple
Definition: trigger.h:35
void pfree(void *pointer)
Definition: mcxt.c:1056
#define TRIGGER_FIRED_BY_TRUNCATE(event)
Definition: trigger.h:125
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
#define ERROR
Definition: elog.h:43
#define DatumGetCString(X)
Definition: postgres.h:566
char * tgname
Definition: reltrigger.h:27
Oid rd_id
Definition: rel.h:85
char ** tgargs
Definition: reltrigger.h:40
#define TRIGGER_FIRED_BY_DELETE(event)
Definition: trigger.h:119
Trigger * tg_trigger
Definition: trigger.h:37
HeapTuple tg_newtuple
Definition: trigger.h:36
char * SPI_getrelname(Relation rel)
Definition: spi.c:1102
#define PG_CATCH()
Definition: elog.h:332
TriggerEvent tg_event
Definition: trigger.h:33
PyObject * PLy_input_from_tuple(PLyDatumToOb *arg, HeapTuple tuple, TupleDesc desc, bool include_generated)
Definition: plpy_typeio.c:133
char * SPI_getnspname(Relation rel)
Definition: spi.c:1108
PLyDatumToOb result_in
#define PG_RE_THROW()
Definition: elog.h:363
#define TRIGGER_FIRED_BEFORE(event)
Definition: trigger.h:134
#define TRIGGER_FIRED_INSTEAD(event)
Definition: trigger.h:140
#define TRIGGER_FIRED_BY_INSERT(event)
Definition: trigger.h:116
#define elog(elevel,...)
Definition: elog.h:228
int i
int16 tgnargs
Definition: reltrigger.h:37
#define PG_TRY()
Definition: elog.h:322
#define TRIGGER_FIRED_FOR_ROW(event)
Definition: trigger.h:128
#define TRIGGER_FIRED_BY_UPDATE(event)
Definition: trigger.h:122
#define PG_END_TRY()
Definition: elog.h:347
Relation tg_relation
Definition: trigger.h:34