Age Owner Branch data TLA Line data Source code
1 : : /*
2 : : * executing Python code
3 : : *
4 : : * src/pl/plpython/plpy_exec.c
5 : : */
6 : :
7 : : #include "postgres.h"
8 : :
9 : : #include "access/htup_details.h"
10 : : #include "access/xact.h"
11 : : #include "catalog/pg_type.h"
12 : : #include "commands/trigger.h"
13 : : #include "executor/spi.h"
14 : : #include "funcapi.h"
15 : : #include "plpy_elog.h"
16 : : #include "plpy_exec.h"
17 : : #include "plpy_main.h"
18 : : #include "plpy_procedure.h"
19 : : #include "plpy_subxactobject.h"
20 : : #include "plpython.h"
21 : : #include "utils/builtins.h"
22 : : #include "utils/lsyscache.h"
23 : : #include "utils/rel.h"
24 : : #include "utils/typcache.h"
25 : :
26 : : /* saved state for a set-returning function */
27 : : typedef struct PLySRFState
28 : : {
29 : : PyObject *iter; /* Python iterator producing results */
30 : : PLySavedArgs *savedargs; /* function argument values */
31 : : MemoryContextCallback callback; /* for releasing refcounts when done */
32 : : } PLySRFState;
33 : :
34 : : static PyObject *PLy_function_build_args(FunctionCallInfo fcinfo, PLyProcedure *proc);
35 : : static PLySavedArgs *PLy_function_save_args(PLyProcedure *proc);
36 : : static void PLy_function_restore_args(PLyProcedure *proc, PLySavedArgs *savedargs);
37 : : static void PLy_function_drop_args(PLySavedArgs *savedargs);
38 : : static void PLy_global_args_push(PLyProcedure *proc);
39 : : static void PLy_global_args_pop(PLyProcedure *proc);
40 : : static void plpython_srf_cleanup_callback(void *arg);
41 : : static void plpython_return_error_callback(void *arg);
42 : :
43 : : static PyObject *PLy_trigger_build_args(FunctionCallInfo fcinfo, PLyProcedure *proc,
44 : : HeapTuple *rv);
45 : : static HeapTuple PLy_modify_tuple(PLyProcedure *proc, PyObject *pltd,
46 : : TriggerData *tdata, HeapTuple otup);
47 : : static void plpython_trigger_error_callback(void *arg);
48 : :
49 : : static PyObject *PLy_procedure_call(PLyProcedure *proc, const char *kargs, PyObject *vargs);
50 : : static void PLy_abort_open_subtransactions(int save_subxact_level);
51 : :
52 : :
53 : : /* function subhandler */
54 : : Datum
4501 peter_e@gmx.net 55 :CBC 650 : PLy_exec_function(FunctionCallInfo fcinfo, PLyProcedure *proc)
56 : : {
2427 57 : 650 : bool is_setof = proc->is_setof;
58 : : Datum rv;
4501 59 : 650 : PyObject *volatile plargs = NULL;
60 : 650 : PyObject *volatile plrv = NULL;
2931 tgl@sss.pgh.pa.us 61 : 650 : FuncCallContext *volatile funcctx = NULL;
62 : 650 : 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 : : */
70 : 650 : PLy_global_args_push(proc);
71 : :
4501 peter_e@gmx.net 72 [ + + ]: 650 : PG_TRY();
73 : : {
2427 74 [ + + ]: 650 : if (is_setof)
75 : : {
76 : : /* First Call setup */
2931 tgl@sss.pgh.pa.us 77 [ + + ]: 192 : if (SRF_IS_FIRSTCALL())
78 : : {
79 : 49 : funcctx = SRF_FIRSTCALL_INIT();
80 : 49 : srfstate = (PLySRFState *)
81 : 49 : MemoryContextAllocZero(funcctx->multi_call_memory_ctx,
82 : : sizeof(PLySRFState));
83 : : /* Immediately register cleanup callback */
84 : 49 : srfstate->callback.func = plpython_srf_cleanup_callback;
85 : 49 : srfstate->callback.arg = (void *) srfstate;
86 : 49 : MemoryContextRegisterResetCallback(funcctx->multi_call_memory_ctx,
87 : 49 : &srfstate->callback);
88 : 49 : funcctx->user_fctx = (void *) srfstate;
89 : : }
90 : : /* Every call setup */
91 : 192 : funcctx = SRF_PERCALL_SETUP();
92 [ - + ]: 192 : Assert(funcctx != NULL);
93 : 192 : srfstate = (PLySRFState *) funcctx->user_fctx;
2427 peter_e@gmx.net 94 [ - + ]: 192 : Assert(srfstate != NULL);
95 : : }
96 : :
2931 tgl@sss.pgh.pa.us 97 [ + + + + ]: 650 : 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 : : */
4501 peter_e@gmx.net 103 : 507 : plargs = PLy_function_build_args(fcinfo, proc);
104 : 507 : plrv = PLy_procedure_call(proc, "args", plargs);
105 [ - + ]: 453 : 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 : : */
2931 tgl@sss.pgh.pa.us 117 [ + - ]: 143 : if (srfstate->savedargs)
118 : 143 : PLy_function_restore_args(proc, srfstate->savedargs);
119 : 143 : 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 : : */
2427 peter_e@gmx.net 127 [ + + ]: 596 : if (is_setof)
128 : : {
2931 tgl@sss.pgh.pa.us 129 [ + + ]: 191 : if (srfstate->iter == NULL)
130 : : {
131 : : /* first time -- do checks and setup */
132 : 48 : ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
133 : :
4501 peter_e@gmx.net 134 [ + - + - ]: 48 : if (!rsi || !IsA(rsi, ReturnSetInfo) ||
135 [ - + ]: 48 : (rsi->allowedModes & SFRM_ValuePerCall) == 0)
136 : : {
4501 peter_e@gmx.net 137 [ # # ]:UBC 0 : 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 : : }
4501 peter_e@gmx.net 142 :CBC 48 : rsi->returnMode = SFRM_ValuePerCall;
143 : :
144 : : /* Make iterator out of returned object */
2931 tgl@sss.pgh.pa.us 145 : 48 : srfstate->iter = PyObject_GetIter(plrv);
146 : :
4501 peter_e@gmx.net 147 : 48 : Py_DECREF(plrv);
148 : 48 : plrv = NULL;
149 : :
2931 tgl@sss.pgh.pa.us 150 [ + + ]: 48 : if (srfstate->iter == NULL)
4501 peter_e@gmx.net 151 [ + - ]: 1 : 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 */
2931 tgl@sss.pgh.pa.us 158 : 190 : plrv = PyIter_Next(srfstate->iter);
159 [ + + ]: 190 : if (plrv == NULL)
160 : : {
161 : : /* Iterator is exhausted or error happened */
162 : 45 : bool has_error = (PyErr_Occurred() != NULL);
163 : :
164 : 45 : Py_DECREF(srfstate->iter);
165 : 45 : srfstate->iter = NULL;
166 : :
4501 peter_e@gmx.net 167 [ + + ]: 45 : if (has_error)
4501 peter_e@gmx.net 168 :UBC 0 : PLy_elog(ERROR, "error fetching next item from iterator");
169 : :
170 : : /* Pass a null through the data-returning steps below */
2931 tgl@sss.pgh.pa.us 171 :CBC 44 : Py_INCREF(Py_None);
172 : 44 : 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 : 145 : 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 : : */
4501 peter_e@gmx.net 191 [ - + ]: 594 : if (SPI_finish() != SPI_OK_FINISH)
4501 peter_e@gmx.net 192 [ # # ]:UBC 0 : elog(ERROR, "SPI_finish failed");
193 : :
4501 peter_e@gmx.net 194 :CBC 594 : plerrcontext.callback = plpython_return_error_callback;
195 : 594 : plerrcontext.previous = error_context_stack;
196 : 594 : 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 : : */
2223 204 [ + + ]: 594 : if (proc->result.typoid == VOIDOID)
205 : : {
2327 206 [ + + ]: 29 : if (plrv != Py_None)
207 : : {
2223 208 [ + + ]: 2 : if (proc->is_procedure)
209 [ + - ]: 1 : ereport(ERROR,
210 : : (errcode(ERRCODE_DATATYPE_MISMATCH),
211 : : errmsg("PL/Python procedure did not return None")));
212 : : else
213 [ + - ]: 1 : ereport(ERROR,
214 : : (errcode(ERRCODE_DATATYPE_MISMATCH),
215 : : errmsg("PL/Python function with return type \"void\" did not return None")));
216 : : }
217 : :
4501 218 : 27 : fcinfo->isnull = false;
219 : 27 : rv = (Datum) 0;
220 : : }
2341 tgl@sss.pgh.pa.us 221 [ + + + + ]: 565 : else if (plrv == Py_None &&
222 [ + + ]: 50 : 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 : 44 : fcinfo->isnull = true;
230 : 44 : rv = (Datum) 0;
231 : : }
232 : : else
233 : : {
234 : : /* Normal conversion of result */
235 : 521 : rv = PLy_output_convert(&proc->result, plrv,
236 : : &fcinfo->isnull);
237 : : }
238 : : }
4501 peter_e@gmx.net 239 : 92 : PG_CATCH();
240 : : {
241 : : /* Pop old arguments from the stack if they were pushed above */
2931 tgl@sss.pgh.pa.us 242 : 92 : PLy_global_args_pop(proc);
243 : :
4501 peter_e@gmx.net 244 : 92 : Py_XDECREF(plargs);
245 : 92 : 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 : : */
2931 tgl@sss.pgh.pa.us 254 [ + + ]: 92 : if (srfstate)
255 : : {
256 : 5 : Py_XDECREF(srfstate->iter);
257 : 5 : srfstate->iter = NULL;
258 : : /* And drop any saved args; we won't need them */
259 [ + + ]: 5 : if (srfstate->savedargs)
260 : 2 : PLy_function_drop_args(srfstate->savedargs);
261 : 5 : srfstate->savedargs = NULL;
262 : : }
263 : :
4501 peter_e@gmx.net 264 : 92 : PG_RE_THROW();
265 : : }
266 [ - + ]: 558 : PG_END_TRY();
267 : :
268 : 558 : error_context_stack = plerrcontext.previous;
269 : :
270 : : /* Pop old arguments from the stack if they were pushed above */
2931 tgl@sss.pgh.pa.us 271 : 558 : PLy_global_args_pop(proc);
272 : :
4501 peter_e@gmx.net 273 : 558 : Py_XDECREF(plargs);
274 : 558 : Py_DECREF(plrv);
275 : :
2931 tgl@sss.pgh.pa.us 276 [ + + ]: 558 : if (srfstate)
277 : : {
278 : : /* We're in a SRF, exit appropriately */
279 [ + + ]: 187 : if (srfstate->iter == NULL)
280 : : {
281 : : /* Iterator exhausted, so we're done */
282 : 44 : SRF_RETURN_DONE(funcctx);
283 : : }
284 [ + + ]: 143 : else if (fcinfo->isnull)
285 : 6 : SRF_RETURN_NEXT_NULL(funcctx);
286 : : else
287 : 137 : SRF_RETURN_NEXT(funcctx, rv);
288 : : }
289 : :
290 : : /* Plain function, just return the Datum value (possibly null) */
4501 peter_e@gmx.net 291 : 371 : return rv;
292 : : }
293 : :
294 : : /* trigger subhandler
295 : : *
296 : : * the python function is expected to return Py_None if the tuple is
297 : : * acceptable and unmodified. Otherwise it should return a PyUnicode
298 : : * object who's value is SKIP, or MODIFY. SKIP means don't perform
299 : : * this action. MODIFY means the tuple has been modified, so update
300 : : * tuple and perform action. SKIP and MODIFY assume the trigger fires
301 : : * BEFORE the event and is ROW level. postgres expects the function
302 : : * to take no arguments and return an argument of type trigger.
303 : : */
304 : : HeapTuple
305 : 46 : PLy_exec_trigger(FunctionCallInfo fcinfo, PLyProcedure *proc)
306 : : {
307 : 46 : HeapTuple rv = NULL;
308 : 46 : PyObject *volatile plargs = NULL;
309 : 46 : PyObject *volatile plrv = NULL;
310 : : TriggerData *tdata;
311 : : TupleDesc rel_descr;
312 : :
313 [ + - - + ]: 46 : Assert(CALLED_AS_TRIGGER(fcinfo));
2341 tgl@sss.pgh.pa.us 314 : 46 : 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 : 46 : rel_descr = RelationGetDescr(tdata->tg_relation);
325 [ + + ]: 46 : if (proc->result.typoid != rel_descr->tdtypeid)
326 : 25 : PLy_output_setup_func(&proc->result, proc->mcxt,
327 : : rel_descr->tdtypeid,
328 : : rel_descr->tdtypmod,
329 : : proc);
330 [ + + ]: 46 : if (proc->result_in.typoid != rel_descr->tdtypeid)
331 : 25 : PLy_input_setup_func(&proc->result_in, proc->mcxt,
332 : : rel_descr->tdtypeid,
333 : : rel_descr->tdtypmod,
334 : : proc);
335 : 46 : PLy_output_setup_tuple(&proc->result, rel_descr, proc);
336 : 46 : PLy_input_setup_tuple(&proc->result_in, rel_descr, proc);
337 : :
4501 peter_e@gmx.net 338 [ + + ]: 46 : PG_TRY();
339 : : {
340 : : int rc PG_USED_FOR_ASSERTS_ONLY;
341 : :
2567 kgrittn@postgresql.o 342 : 46 : rc = SPI_register_trigger_data(tdata);
343 [ - + ]: 46 : Assert(rc >= 0);
344 : :
4501 peter_e@gmx.net 345 : 46 : plargs = PLy_trigger_build_args(fcinfo, proc, &rv);
346 : 46 : plrv = PLy_procedure_call(proc, "TD", plargs);
347 : :
348 [ - + ]: 46 : Assert(plrv != NULL);
349 : :
350 : : /*
351 : : * Disconnect from SPI manager
352 : : */
353 [ - + ]: 46 : if (SPI_finish() != SPI_OK_FINISH)
4501 peter_e@gmx.net 354 [ # # ]:UBC 0 : elog(ERROR, "SPI_finish failed");
355 : :
356 : : /*
357 : : * return of None means we're happy with the tuple
358 : : */
4501 peter_e@gmx.net 359 [ + + ]:CBC 46 : if (plrv != Py_None)
360 : : {
361 : : char *srv;
362 : :
769 andres@anarazel.de 363 [ + + ]: 25 : if (PyUnicode_Check(plrv))
4501 peter_e@gmx.net 364 : 24 : srv = PLyUnicode_AsString(plrv);
365 : : else
366 : : {
367 [ + - ]: 1 : ereport(ERROR,
368 : : (errcode(ERRCODE_DATA_EXCEPTION),
369 : : errmsg("unexpected return value from trigger procedure"),
370 : : errdetail("Expected None or a string.")));
371 : : srv = NULL; /* keep compiler quiet */
372 : : }
373 : :
374 [ + + ]: 24 : if (pg_strcasecmp(srv, "SKIP") == 0)
375 : 1 : rv = NULL;
376 [ + + ]: 23 : else if (pg_strcasecmp(srv, "MODIFY") == 0)
377 : : {
378 [ + + ]: 21 : if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event) ||
379 [ + + ]: 9 : TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
380 : 20 : rv = PLy_modify_tuple(proc, plargs, tdata, rv);
381 : : else
382 [ + - ]: 1 : ereport(WARNING,
383 : : (errmsg("PL/Python trigger function returned \"MODIFY\" in a DELETE trigger -- ignored")));
384 : : }
385 [ + - ]: 2 : else if (pg_strcasecmp(srv, "OK") != 0)
386 : : {
387 : : /*
388 : : * accept "OK" as an alternative to None; otherwise, raise an
389 : : * error
390 : : */
391 [ + - ]: 2 : ereport(ERROR,
392 : : (errcode(ERRCODE_DATA_EXCEPTION),
393 : : errmsg("unexpected return value from trigger procedure"),
394 : : errdetail("Expected None, \"OK\", \"SKIP\", or \"MODIFY\".")));
395 : : }
396 : : }
397 : : }
1626 peter@eisentraut.org 398 : 9 : PG_FINALLY();
399 : : {
4501 peter_e@gmx.net 400 : 46 : Py_XDECREF(plargs);
401 : 46 : Py_XDECREF(plrv);
402 : : }
403 [ + + ]: 46 : PG_END_TRY();
404 : :
405 : 37 : return rv;
406 : : }
407 : :
408 : : /* helper functions for Python code execution */
409 : :
410 : : static PyObject *
411 : 507 : PLy_function_build_args(FunctionCallInfo fcinfo, PLyProcedure *proc)
412 : : {
413 : 507 : PyObject *volatile arg = NULL;
414 : : PyObject *args;
415 : : int i;
416 : :
417 : : /*
418 : : * Make any Py*_New() calls before the PG_TRY block so that we can quickly
419 : : * return NULL on failure. We can't return within the PG_TRY block, else
420 : : * we'd miss unwinding the exception stack.
421 : : */
347 nathan@postgresql.or 422 : 507 : args = PyList_New(proc->nargs);
423 [ - + ]: 507 : if (!args)
347 nathan@postgresql.or 424 :UBC 0 : return NULL;
425 : :
4501 peter_e@gmx.net 426 [ + - ]:CBC 507 : PG_TRY();
427 : : {
428 [ + + ]: 1212 : for (i = 0; i < proc->nargs; i++)
429 : : {
2341 tgl@sss.pgh.pa.us 430 : 705 : PLyDatumToOb *arginfo = &proc->args[i];
431 : :
1905 andres@anarazel.de 432 [ + + ]: 705 : if (fcinfo->args[i].isnull)
2341 tgl@sss.pgh.pa.us 433 : 120 : arg = NULL;
434 : : else
1905 andres@anarazel.de 435 : 585 : arg = PLy_input_convert(arginfo, fcinfo->args[i].value);
436 : :
4501 peter_e@gmx.net 437 [ + + ]: 705 : if (arg == NULL)
438 : : {
439 : 120 : Py_INCREF(Py_None);
440 : 120 : arg = Py_None;
441 : : }
442 : :
443 [ - + ]: 705 : if (PyList_SetItem(args, i, arg) == -1)
4501 peter_e@gmx.net 444 :UBC 0 : PLy_elog(ERROR, "PyList_SetItem() failed, while setting up arguments");
445 : :
4501 peter_e@gmx.net 446 [ + - + + ]:CBC 705 : if (proc->argnames && proc->argnames[i] &&
2489 tgl@sss.pgh.pa.us 447 [ - + ]: 702 : PyDict_SetItemString(proc->globals, proc->argnames[i], arg) == -1)
4501 peter_e@gmx.net 448 :UBC 0 : PLy_elog(ERROR, "PyDict_SetItemString() failed, while setting up arguments");
4501 peter_e@gmx.net 449 :CBC 705 : arg = NULL;
450 : : }
451 : :
452 : : /* Set up output conversion for functions returning RECORD */
2341 tgl@sss.pgh.pa.us 453 [ + + ]: 507 : if (proc->result.typoid == RECORDOID)
454 : : {
455 : : TupleDesc desc;
456 : :
4501 peter_e@gmx.net 457 [ - + ]: 74 : if (get_call_result_type(fcinfo, NULL, &desc) != TYPEFUNC_COMPOSITE)
4501 peter_e@gmx.net 458 [ # # ]:UBC 0 : ereport(ERROR,
459 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
460 : : errmsg("function returning record called in context "
461 : : "that cannot accept type record")));
462 : :
463 : : /* cache the output conversion functions */
2341 tgl@sss.pgh.pa.us 464 :CBC 74 : PLy_output_setup_record(&proc->result, desc, proc);
465 : : }
466 : : }
4501 peter_e@gmx.net 467 :UBC 0 : PG_CATCH();
468 : : {
469 : 0 : Py_XDECREF(arg);
470 : 0 : Py_XDECREF(args);
471 : :
472 : 0 : PG_RE_THROW();
473 : : }
4501 peter_e@gmx.net 474 [ - + ]:CBC 507 : PG_END_TRY();
475 : :
476 : 507 : return args;
477 : : }
478 : :
479 : : /*
480 : : * Construct a PLySavedArgs struct representing the current values of the
481 : : * procedure's arguments in its globals dict. This can be used to restore
482 : : * those values when exiting a recursive call level or returning control to a
483 : : * set-returning function.
484 : : *
485 : : * This would not be necessary except for an ancient decision to make args
486 : : * available via the proc's globals :-( ... but we're stuck with that now.
487 : : */
488 : : static PLySavedArgs *
2931 tgl@sss.pgh.pa.us 489 : 154 : PLy_function_save_args(PLyProcedure *proc)
490 : : {
491 : : PLySavedArgs *result;
492 : :
493 : : /* saved args are always allocated in procedure's context */
494 : : result = (PLySavedArgs *)
495 : 154 : MemoryContextAllocZero(proc->mcxt,
496 : 154 : offsetof(PLySavedArgs, namedargs) +
497 : 154 : proc->nargs * sizeof(PyObject *));
498 : 154 : result->nargs = proc->nargs;
499 : :
500 : : /* Fetch the "args" list */
501 : 154 : result->args = PyDict_GetItemString(proc->globals, "args");
502 : 154 : Py_XINCREF(result->args);
503 : :
504 : : /* Fetch all the named arguments */
505 [ + + ]: 154 : if (proc->argnames)
506 : : {
507 : : int i;
508 : :
509 [ + + ]: 299 : for (i = 0; i < result->nargs; i++)
510 : : {
511 [ + - ]: 207 : if (proc->argnames[i])
512 : : {
513 : 414 : result->namedargs[i] = PyDict_GetItemString(proc->globals,
2489 514 : 207 : proc->argnames[i]);
2931 515 : 207 : Py_XINCREF(result->namedargs[i]);
516 : : }
517 : : }
518 : : }
519 : :
520 : 154 : return result;
521 : : }
522 : :
523 : : /*
524 : : * Restore procedure's arguments from a PLySavedArgs struct,
525 : : * then free the struct.
526 : : */
527 : : static void
528 : 152 : PLy_function_restore_args(PLyProcedure *proc, PLySavedArgs *savedargs)
529 : : {
530 : : /* Restore named arguments into their slots in the globals dict */
531 [ + + ]: 152 : if (proc->argnames)
532 : : {
533 : : int i;
534 : :
535 [ + + ]: 299 : for (i = 0; i < savedargs->nargs; i++)
536 : : {
537 [ + - + - ]: 207 : if (proc->argnames[i] && savedargs->namedargs[i])
538 : : {
539 : 207 : PyDict_SetItemString(proc->globals, proc->argnames[i],
540 : : savedargs->namedargs[i]);
541 : 207 : Py_DECREF(savedargs->namedargs[i]);
542 : : }
543 : : }
544 : : }
545 : :
546 : : /* Restore the "args" object, too */
547 [ + - ]: 152 : if (savedargs->args)
548 : : {
549 : 152 : PyDict_SetItemString(proc->globals, "args", savedargs->args);
550 : 152 : Py_DECREF(savedargs->args);
551 : : }
552 : :
553 : : /* And free the PLySavedArgs struct */
554 : 152 : pfree(savedargs);
555 : 152 : }
556 : :
557 : : /*
558 : : * Free a PLySavedArgs struct without restoring the values.
559 : : */
560 : : static void
561 : 2 : PLy_function_drop_args(PLySavedArgs *savedargs)
562 : : {
563 : : int i;
564 : :
565 : : /* Drop references for named args */
566 [ - + ]: 2 : for (i = 0; i < savedargs->nargs; i++)
567 : : {
2931 tgl@sss.pgh.pa.us 568 :UBC 0 : Py_XDECREF(savedargs->namedargs[i]);
569 : : }
570 : :
571 : : /* Drop ref to the "args" object, too */
2931 tgl@sss.pgh.pa.us 572 :CBC 2 : Py_XDECREF(savedargs->args);
573 : :
574 : : /* And free the PLySavedArgs struct */
575 : 2 : pfree(savedargs);
576 : 2 : }
577 : :
578 : : /*
579 : : * Save away any existing arguments for the given procedure, so that we can
580 : : * install new values for a recursive call. This should be invoked before
581 : : * doing PLy_function_build_args().
582 : : *
583 : : * NB: caller must ensure that PLy_global_args_pop gets invoked once, and
584 : : * only once, per successful completion of PLy_global_args_push. Otherwise
585 : : * we'll end up out-of-sync between the actual call stack and the contents
586 : : * of proc->argstack.
587 : : */
588 : : static void
589 : 650 : PLy_global_args_push(PLyProcedure *proc)
590 : : {
591 : : /* We only need to push if we are already inside some active call */
592 [ + + ]: 650 : if (proc->calldepth > 0)
593 : : {
594 : : PLySavedArgs *node;
595 : :
596 : : /* Build a struct containing current argument values */
597 : 9 : node = PLy_function_save_args(proc);
598 : :
599 : : /*
600 : : * Push the saved argument values into the procedure's stack. Once we
601 : : * modify either proc->argstack or proc->calldepth, we had better
602 : : * return without the possibility of error.
603 : : */
604 : 9 : node->next = proc->argstack;
605 : 9 : proc->argstack = node;
606 : : }
607 : 650 : proc->calldepth++;
608 : 650 : }
609 : :
610 : : /*
611 : : * Pop old arguments when exiting a recursive call.
612 : : *
613 : : * Note: the idea here is to adjust the proc's callstack state before doing
614 : : * anything that could possibly fail. In event of any error, we want the
615 : : * callstack to look like we've done the pop. Leaking a bit of memory is
616 : : * tolerable.
617 : : */
618 : : static void
619 : 650 : PLy_global_args_pop(PLyProcedure *proc)
620 : : {
621 [ - + ]: 650 : Assert(proc->calldepth > 0);
622 : : /* We only need to pop if we were already inside some active call */
623 [ + + ]: 650 : if (proc->calldepth > 1)
624 : : {
625 : 9 : PLySavedArgs *ptr = proc->argstack;
626 : :
627 : : /* Pop the callstack */
628 [ - + ]: 9 : Assert(ptr != NULL);
629 : 9 : proc->argstack = ptr->next;
630 : 9 : proc->calldepth--;
631 : :
632 : : /* Restore argument values, then free ptr */
633 : 9 : PLy_function_restore_args(proc, ptr);
634 : : }
635 : : else
636 : : {
637 : : /* Exiting call depth 1 */
638 [ - + ]: 641 : Assert(proc->argstack == NULL);
639 : 641 : proc->calldepth--;
640 : :
641 : : /*
642 : : * We used to delete the named arguments (but not "args") from the
643 : : * proc's globals dict when exiting the outermost call level for a
644 : : * function. This seems rather pointless though: nothing can see the
645 : : * dict until the function is called again, at which time we'll
646 : : * overwrite those dict entries. So don't bother with that.
647 : : */
648 : : }
649 : 650 : }
650 : :
651 : : /*
652 : : * Memory context deletion callback for cleaning up a PLySRFState.
653 : : * We need this in case execution of the SRF is terminated early,
654 : : * due to error or the caller simply not running it to completion.
655 : : */
656 : : static void
657 : 49 : plpython_srf_cleanup_callback(void *arg)
658 : : {
659 : 49 : PLySRFState *srfstate = (PLySRFState *) arg;
660 : :
661 : : /* Release refcount on the iter, if we still have one */
662 : 49 : Py_XDECREF(srfstate->iter);
663 : 49 : srfstate->iter = NULL;
664 : : /* And drop any saved args; we won't need them */
665 [ - + ]: 49 : if (srfstate->savedargs)
2931 tgl@sss.pgh.pa.us 666 :UBC 0 : PLy_function_drop_args(srfstate->savedargs);
2931 tgl@sss.pgh.pa.us 667 :CBC 49 : srfstate->savedargs = NULL;
4501 peter_e@gmx.net 668 : 49 : }
669 : :
670 : : static void
671 : 37 : plpython_return_error_callback(void *arg)
672 : : {
4415 tgl@sss.pgh.pa.us 673 : 37 : PLyExecutionContext *exec_ctx = PLy_current_execution_context();
674 : :
2327 peter_e@gmx.net 675 [ + - ]: 37 : if (exec_ctx->curr_proc &&
676 [ + + ]: 37 : !exec_ctx->curr_proc->is_procedure)
4501 677 : 36 : errcontext("while creating return value");
678 : 37 : }
679 : :
680 : : static PyObject *
681 : 46 : PLy_trigger_build_args(FunctionCallInfo fcinfo, PLyProcedure *proc, HeapTuple *rv)
682 : : {
683 : 46 : TriggerData *tdata = (TriggerData *) fcinfo->context;
2341 tgl@sss.pgh.pa.us 684 : 46 : TupleDesc rel_descr = RelationGetDescr(tdata->tg_relation);
685 : : PyObject *pltname,
686 : : *pltevent,
687 : : *pltwhen,
688 : : *pltlevel,
689 : : *pltrelid,
690 : : *plttablename,
691 : : *plttableschema,
692 : : *pltargs,
693 : : *pytnew,
694 : : *pytold,
695 : : *pltdata;
696 : : char *stroid;
697 : :
698 : : /*
699 : : * Make any Py*_New() calls before the PG_TRY block so that we can quickly
700 : : * return NULL on failure. We can't return within the PG_TRY block, else
701 : : * we'd miss unwinding the exception stack.
702 : : */
347 nathan@postgresql.or 703 : 46 : pltdata = PyDict_New();
704 [ - + ]: 46 : if (!pltdata)
347 nathan@postgresql.or 705 :UBC 0 : return NULL;
706 : :
347 nathan@postgresql.or 707 [ + + ]:CBC 46 : if (tdata->tg_trigger->tgnargs)
708 : : {
709 : 16 : pltargs = PyList_New(tdata->tg_trigger->tgnargs);
710 [ - + ]: 16 : if (!pltargs)
711 : : {
347 nathan@postgresql.or 712 :UBC 0 : Py_DECREF(pltdata);
2357 peter_e@gmx.net 713 : 0 : return NULL;
714 : : }
715 : : }
716 : : else
717 : : {
13 tgl@sss.pgh.pa.us 718 :CBC 30 : Py_INCREF(Py_None);
719 : 30 : pltargs = Py_None;
720 : : }
721 : :
347 nathan@postgresql.or 722 [ + - ]: 46 : PG_TRY();
723 : : {
769 andres@anarazel.de 724 : 46 : pltname = PLyUnicode_FromString(tdata->tg_trigger->tgname);
4501 peter_e@gmx.net 725 : 46 : PyDict_SetItemString(pltdata, "name", pltname);
726 : 46 : Py_DECREF(pltname);
727 : :
728 : 46 : stroid = DatumGetCString(DirectFunctionCall1(oidout,
729 : : ObjectIdGetDatum(tdata->tg_relation->rd_id)));
769 andres@anarazel.de 730 : 46 : pltrelid = PLyUnicode_FromString(stroid);
4501 peter_e@gmx.net 731 : 46 : PyDict_SetItemString(pltdata, "relid", pltrelid);
732 : 46 : Py_DECREF(pltrelid);
733 : 46 : pfree(stroid);
734 : :
735 : 46 : stroid = SPI_getrelname(tdata->tg_relation);
769 andres@anarazel.de 736 : 46 : plttablename = PLyUnicode_FromString(stroid);
4501 peter_e@gmx.net 737 : 46 : PyDict_SetItemString(pltdata, "table_name", plttablename);
738 : 46 : Py_DECREF(plttablename);
739 : 46 : pfree(stroid);
740 : :
741 : 46 : stroid = SPI_getnspname(tdata->tg_relation);
769 andres@anarazel.de 742 : 46 : plttableschema = PLyUnicode_FromString(stroid);
4501 peter_e@gmx.net 743 : 46 : PyDict_SetItemString(pltdata, "table_schema", plttableschema);
744 : 46 : Py_DECREF(plttableschema);
745 : 46 : pfree(stroid);
746 : :
747 [ + + ]: 46 : if (TRIGGER_FIRED_BEFORE(tdata->tg_event))
769 andres@anarazel.de 748 : 36 : pltwhen = PLyUnicode_FromString("BEFORE");
4501 peter_e@gmx.net 749 [ + + ]: 10 : else if (TRIGGER_FIRED_AFTER(tdata->tg_event))
769 andres@anarazel.de 750 : 7 : pltwhen = PLyUnicode_FromString("AFTER");
4501 peter_e@gmx.net 751 [ + - ]: 3 : else if (TRIGGER_FIRED_INSTEAD(tdata->tg_event))
769 andres@anarazel.de 752 : 3 : pltwhen = PLyUnicode_FromString("INSTEAD OF");
753 : : else
754 : : {
4501 peter_e@gmx.net 755 [ # # ]:UBC 0 : elog(ERROR, "unrecognized WHEN tg_event: %u", tdata->tg_event);
756 : : pltwhen = NULL; /* keep compiler quiet */
757 : : }
4501 peter_e@gmx.net 758 :CBC 46 : PyDict_SetItemString(pltdata, "when", pltwhen);
759 : 46 : Py_DECREF(pltwhen);
760 : :
761 [ + + ]: 46 : if (TRIGGER_FIRED_FOR_ROW(tdata->tg_event))
762 : : {
769 andres@anarazel.de 763 : 41 : pltlevel = PLyUnicode_FromString("ROW");
4501 peter_e@gmx.net 764 : 41 : PyDict_SetItemString(pltdata, "level", pltlevel);
765 : 41 : Py_DECREF(pltlevel);
766 : :
767 : : /*
768 : : * Note: In BEFORE trigger, stored generated columns are not
769 : : * computed yet, so don't make them accessible in NEW row.
770 : : */
771 : :
772 [ + + ]: 41 : if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event))
773 : : {
769 andres@anarazel.de 774 : 19 : pltevent = PLyUnicode_FromString("INSERT");
775 : :
4501 peter_e@gmx.net 776 : 19 : PyDict_SetItemString(pltdata, "old", Py_None);
2341 tgl@sss.pgh.pa.us 777 : 38 : pytnew = PLy_input_from_tuple(&proc->result_in,
778 : : tdata->tg_trigtuple,
779 : : rel_descr,
1842 peter@eisentraut.org 780 : 19 : !TRIGGER_FIRED_BEFORE(tdata->tg_event));
4501 peter_e@gmx.net 781 : 19 : PyDict_SetItemString(pltdata, "new", pytnew);
782 : 19 : Py_DECREF(pytnew);
783 : 19 : *rv = tdata->tg_trigtuple;
784 : : }
785 [ + + ]: 22 : else if (TRIGGER_FIRED_BY_DELETE(tdata->tg_event))
786 : : {
769 andres@anarazel.de 787 : 6 : pltevent = PLyUnicode_FromString("DELETE");
788 : :
4501 peter_e@gmx.net 789 : 6 : PyDict_SetItemString(pltdata, "new", Py_None);
2341 tgl@sss.pgh.pa.us 790 : 6 : pytold = PLy_input_from_tuple(&proc->result_in,
791 : : tdata->tg_trigtuple,
792 : : rel_descr,
793 : : true);
4501 peter_e@gmx.net 794 : 6 : PyDict_SetItemString(pltdata, "old", pytold);
795 : 6 : Py_DECREF(pytold);
796 : 6 : *rv = tdata->tg_trigtuple;
797 : : }
798 [ + - ]: 16 : else if (TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
799 : : {
769 andres@anarazel.de 800 : 16 : pltevent = PLyUnicode_FromString("UPDATE");
801 : :
2341 tgl@sss.pgh.pa.us 802 : 32 : pytnew = PLy_input_from_tuple(&proc->result_in,
803 : : tdata->tg_newtuple,
804 : : rel_descr,
1842 peter@eisentraut.org 805 : 16 : !TRIGGER_FIRED_BEFORE(tdata->tg_event));
4501 peter_e@gmx.net 806 : 16 : PyDict_SetItemString(pltdata, "new", pytnew);
807 : 16 : Py_DECREF(pytnew);
2341 tgl@sss.pgh.pa.us 808 : 16 : pytold = PLy_input_from_tuple(&proc->result_in,
809 : : tdata->tg_trigtuple,
810 : : rel_descr,
811 : : true);
4501 peter_e@gmx.net 812 : 16 : PyDict_SetItemString(pltdata, "old", pytold);
813 : 16 : Py_DECREF(pytold);
814 : 16 : *rv = tdata->tg_newtuple;
815 : : }
816 : : else
817 : : {
4501 peter_e@gmx.net 818 [ # # ]:UBC 0 : elog(ERROR, "unrecognized OP tg_event: %u", tdata->tg_event);
819 : : pltevent = NULL; /* keep compiler quiet */
820 : : }
821 : :
4501 peter_e@gmx.net 822 :CBC 41 : PyDict_SetItemString(pltdata, "event", pltevent);
823 : 41 : Py_DECREF(pltevent);
824 : : }
825 [ + - ]: 5 : else if (TRIGGER_FIRED_FOR_STATEMENT(tdata->tg_event))
826 : : {
769 andres@anarazel.de 827 : 5 : pltlevel = PLyUnicode_FromString("STATEMENT");
4501 peter_e@gmx.net 828 : 5 : PyDict_SetItemString(pltdata, "level", pltlevel);
829 : 5 : Py_DECREF(pltlevel);
830 : :
831 : 5 : PyDict_SetItemString(pltdata, "old", Py_None);
832 : 5 : PyDict_SetItemString(pltdata, "new", Py_None);
833 : 5 : *rv = NULL;
834 : :
835 [ + + ]: 5 : if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event))
769 andres@anarazel.de 836 : 1 : pltevent = PLyUnicode_FromString("INSERT");
4501 peter_e@gmx.net 837 [ + + ]: 4 : else if (TRIGGER_FIRED_BY_DELETE(tdata->tg_event))
769 andres@anarazel.de 838 : 1 : pltevent = PLyUnicode_FromString("DELETE");
4501 peter_e@gmx.net 839 [ + + ]: 3 : else if (TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
769 andres@anarazel.de 840 : 2 : pltevent = PLyUnicode_FromString("UPDATE");
4501 peter_e@gmx.net 841 [ + - ]: 1 : else if (TRIGGER_FIRED_BY_TRUNCATE(tdata->tg_event))
769 andres@anarazel.de 842 : 1 : pltevent = PLyUnicode_FromString("TRUNCATE");
843 : : else
844 : : {
4501 peter_e@gmx.net 845 [ # # ]:UBC 0 : elog(ERROR, "unrecognized OP tg_event: %u", tdata->tg_event);
846 : : pltevent = NULL; /* keep compiler quiet */
847 : : }
848 : :
4501 peter_e@gmx.net 849 :CBC 5 : PyDict_SetItemString(pltdata, "event", pltevent);
850 : 5 : Py_DECREF(pltevent);
851 : : }
852 : : else
4501 peter_e@gmx.net 853 [ # # ]:UBC 0 : elog(ERROR, "unrecognized LEVEL tg_event: %u", tdata->tg_event);
854 : :
4501 peter_e@gmx.net 855 [ + + ]:CBC 46 : if (tdata->tg_trigger->tgnargs)
856 : : {
857 : : /*
858 : : * all strings...
859 : : */
860 : : int i;
861 : : PyObject *pltarg;
862 : :
863 : : /* pltargs should have been allocated before the PG_TRY block. */
13 tgl@sss.pgh.pa.us 864 [ + - - + ]: 16 : Assert(pltargs && pltargs != Py_None);
865 : :
4501 peter_e@gmx.net 866 [ + + ]: 45 : for (i = 0; i < tdata->tg_trigger->tgnargs; i++)
867 : : {
769 andres@anarazel.de 868 : 29 : pltarg = PLyUnicode_FromString(tdata->tg_trigger->tgargs[i]);
869 : :
870 : : /*
871 : : * stolen, don't Py_DECREF
872 : : */
4501 peter_e@gmx.net 873 : 29 : PyList_SetItem(pltargs, i, pltarg);
874 : : }
875 : : }
876 : : else
877 : : {
13 tgl@sss.pgh.pa.us 878 [ - + ]: 30 : Assert(pltargs == Py_None);
879 : : }
4501 peter_e@gmx.net 880 : 46 : PyDict_SetItemString(pltdata, "args", pltargs);
881 : 46 : Py_DECREF(pltargs);
882 : : }
4501 peter_e@gmx.net 883 :UBC 0 : PG_CATCH();
884 : : {
347 nathan@postgresql.or 885 : 0 : Py_XDECREF(pltargs);
4501 peter_e@gmx.net 886 : 0 : Py_XDECREF(pltdata);
887 : 0 : PG_RE_THROW();
888 : : }
4501 peter_e@gmx.net 889 [ - + ]:CBC 46 : PG_END_TRY();
890 : :
891 : 46 : return pltdata;
892 : : }
893 : :
894 : : /*
895 : : * Apply changes requested by a MODIFY return from a trigger function.
896 : : */
897 : : static HeapTuple
898 : 20 : PLy_modify_tuple(PLyProcedure *proc, PyObject *pltd, TriggerData *tdata,
899 : : HeapTuple otup)
900 : : {
901 : : HeapTuple rtup;
902 : : PyObject *volatile plntup;
903 : : PyObject *volatile plkeys;
904 : : PyObject *volatile plval;
905 : : Datum *volatile modvalues;
906 : : bool *volatile modnulls;
907 : : bool *volatile modrepls;
908 : : ErrorContextCallback plerrcontext;
909 : :
910 : 20 : plerrcontext.callback = plpython_trigger_error_callback;
911 : 20 : plerrcontext.previous = error_context_stack;
912 : 20 : error_context_stack = &plerrcontext;
913 : :
3672 tgl@sss.pgh.pa.us 914 : 20 : plntup = plkeys = plval = NULL;
4501 peter_e@gmx.net 915 : 20 : modvalues = NULL;
916 : 20 : modnulls = NULL;
2714 tgl@sss.pgh.pa.us 917 : 20 : modrepls = NULL;
918 : :
4501 peter_e@gmx.net 919 [ + + ]: 20 : PG_TRY();
920 : : {
921 : : TupleDesc tupdesc;
922 : : int nkeys,
923 : : i;
924 : :
925 [ + + ]: 20 : if ((plntup = PyDict_GetItemString(pltd, "new")) == NULL)
926 [ + - ]: 1 : ereport(ERROR,
927 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
928 : : errmsg("TD[\"new\"] deleted, cannot modify row")));
3672 tgl@sss.pgh.pa.us 929 : 19 : Py_INCREF(plntup);
4501 peter_e@gmx.net 930 [ + + ]: 19 : if (!PyDict_Check(plntup))
931 [ + - ]: 1 : ereport(ERROR,
932 : : (errcode(ERRCODE_DATATYPE_MISMATCH),
933 : : errmsg("TD[\"new\"] is not a dictionary")));
934 : :
935 : 18 : plkeys = PyDict_Keys(plntup);
2714 tgl@sss.pgh.pa.us 936 : 18 : nkeys = PyList_Size(plkeys);
937 : :
2341 938 : 18 : tupdesc = RelationGetDescr(tdata->tg_relation);
939 : :
2714 940 : 18 : modvalues = (Datum *) palloc0(tupdesc->natts * sizeof(Datum));
941 : 18 : modnulls = (bool *) palloc0(tupdesc->natts * sizeof(bool));
942 : 18 : modrepls = (bool *) palloc0(tupdesc->natts * sizeof(bool));
943 : :
944 [ + + ]: 45 : for (i = 0; i < nkeys; i++)
945 : : {
946 : : PyObject *platt;
947 : : char *plattstr;
948 : : int attn;
949 : : PLyObToDatum *att;
950 : :
4501 peter_e@gmx.net 951 : 31 : platt = PyList_GetItem(plkeys, i);
769 andres@anarazel.de 952 [ + + ]: 31 : if (PyUnicode_Check(platt))
4501 peter_e@gmx.net 953 : 30 : plattstr = PLyUnicode_AsString(platt);
954 : : else
955 : : {
956 [ + - ]: 1 : ereport(ERROR,
957 : : (errcode(ERRCODE_DATATYPE_MISMATCH),
958 : : errmsg("TD[\"new\"] dictionary key at ordinal position %d is not a string", i)));
959 : : plattstr = NULL; /* keep compiler quiet */
960 : : }
961 : 30 : attn = SPI_fnumber(tupdesc, plattstr);
962 [ + + ]: 30 : if (attn == SPI_ERROR_NOATTRIBUTE)
963 [ + - ]: 2 : ereport(ERROR,
964 : : (errcode(ERRCODE_UNDEFINED_COLUMN),
965 : : errmsg("key \"%s\" found in TD[\"new\"] does not exist as a column in the triggering row",
966 : : plattstr)));
2714 tgl@sss.pgh.pa.us 967 [ - + ]: 28 : if (attn <= 0)
2714 tgl@sss.pgh.pa.us 968 [ # # ]:UBC 0 : ereport(ERROR,
969 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
970 : : errmsg("cannot set system attribute \"%s\"",
971 : : plattstr)));
1842 peter@eisentraut.org 972 [ + + ]:CBC 28 : if (TupleDescAttr(tupdesc, attn - 1)->attgenerated)
973 [ + - ]: 1 : ereport(ERROR,
974 : : (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
975 : : errmsg("cannot set generated column \"%s\"",
976 : : plattstr)));
977 : :
4501 peter_e@gmx.net 978 : 27 : plval = PyDict_GetItem(plntup, platt);
979 [ - + ]: 27 : if (plval == NULL)
4501 peter_e@gmx.net 980 [ # # ]:UBC 0 : elog(FATAL, "Python interpreter is probably corrupted");
981 : :
4501 peter_e@gmx.net 982 :CBC 27 : Py_INCREF(plval);
983 : :
984 : : /* We assume proc->result is set up to convert tuples properly */
2341 tgl@sss.pgh.pa.us 985 : 27 : att = &proc->result.u.tuple.atts[attn - 1];
986 : :
987 : 54 : modvalues[attn - 1] = PLy_output_convert(att,
988 : : plval,
989 : 27 : &modnulls[attn - 1]);
2714 990 : 27 : modrepls[attn - 1] = true;
991 : :
4501 peter_e@gmx.net 992 : 27 : Py_DECREF(plval);
993 : 27 : plval = NULL;
994 : : }
995 : :
2714 tgl@sss.pgh.pa.us 996 : 14 : rtup = heap_modify_tuple(otup, tupdesc, modvalues, modnulls, modrepls);
997 : : }
4501 peter_e@gmx.net 998 : 6 : PG_CATCH();
999 : : {
1000 : 6 : Py_XDECREF(plntup);
1001 : 6 : Py_XDECREF(plkeys);
1002 : 6 : Py_XDECREF(plval);
1003 : :
1004 [ + + ]: 6 : if (modvalues)
1005 : 4 : pfree(modvalues);
2714 tgl@sss.pgh.pa.us 1006 [ + + ]: 6 : if (modnulls)
1007 : 4 : pfree(modnulls);
1008 [ + + ]: 6 : if (modrepls)
1009 : 4 : pfree(modrepls);
1010 : :
4501 peter_e@gmx.net 1011 : 6 : PG_RE_THROW();
1012 : : }
1013 [ - + ]: 14 : PG_END_TRY();
1014 : :
1015 : 14 : Py_DECREF(plntup);
1016 : 14 : Py_DECREF(plkeys);
1017 : :
1018 : 14 : pfree(modvalues);
1019 : 14 : pfree(modnulls);
2714 tgl@sss.pgh.pa.us 1020 : 14 : pfree(modrepls);
1021 : :
4501 peter_e@gmx.net 1022 : 14 : error_context_stack = plerrcontext.previous;
1023 : :
1024 : 14 : return rtup;
1025 : : }
1026 : :
1027 : : static void
1028 : 6 : plpython_trigger_error_callback(void *arg)
1029 : : {
4415 tgl@sss.pgh.pa.us 1030 : 6 : PLyExecutionContext *exec_ctx = PLy_current_execution_context();
1031 : :
1032 [ + - ]: 6 : if (exec_ctx->curr_proc)
4501 peter_e@gmx.net 1033 : 6 : errcontext("while modifying trigger row");
1034 : 6 : }
1035 : :
1036 : : /* execute Python code, propagate Python errors to the backend */
1037 : : static PyObject *
2931 tgl@sss.pgh.pa.us 1038 : 553 : PLy_procedure_call(PLyProcedure *proc, const char *kargs, PyObject *vargs)
1039 : : {
1623 peter@eisentraut.org 1040 : 553 : PyObject *rv = NULL;
4501 peter_e@gmx.net 1041 : 553 : int volatile save_subxact_level = list_length(explicit_subtransactions);
1042 : :
1043 : 553 : PyDict_SetItemString(proc->globals, kargs, vargs);
1044 : :
1045 [ + - ]: 553 : PG_TRY();
1046 : : {
1047 : : #if PY_VERSION_HEX >= 0x03020000
1048 : 553 : rv = PyEval_EvalCode(proc->code,
1049 : : proc->globals, proc->globals);
1050 : : #else
1051 : : rv = PyEval_EvalCode((PyCodeObject *) proc->code,
1052 : : proc->globals, proc->globals);
1053 : : #endif
1054 : :
1055 : : /*
1056 : : * Since plpy will only let you close subtransactions that you
1057 : : * started, you cannot *unnest* subtransactions, only *nest* them
1058 : : * without closing.
1059 : : */
1060 [ - + ]: 553 : Assert(list_length(explicit_subtransactions) >= save_subxact_level);
1061 : : }
1626 peter@eisentraut.org 1062 :UBC 0 : PG_FINALLY();
1063 : : {
4501 peter_e@gmx.net 1064 :CBC 553 : PLy_abort_open_subtransactions(save_subxact_level);
1065 : : }
1066 [ - + ]: 553 : PG_END_TRY();
1067 : :
1068 : : /* If the Python code returned an error, propagate it */
1069 [ + + ]: 553 : if (rv == NULL)
4501 peter_e@gmx.net 1070 :UBC 0 : PLy_elog(ERROR, NULL);
1071 : :
4501 peter_e@gmx.net 1072 :CBC 499 : return rv;
1073 : : }
1074 : :
1075 : : /*
1076 : : * Abort lingering subtransactions that have been explicitly started
1077 : : * by plpy.subtransaction().start() and not properly closed.
1078 : : */
1079 : : static void
1080 : 553 : PLy_abort_open_subtransactions(int save_subxact_level)
1081 : : {
1082 [ - + ]: 553 : Assert(save_subxact_level >= 0);
1083 : :
1084 [ + + ]: 559 : while (list_length(explicit_subtransactions) > save_subxact_level)
1085 : : {
1086 : : PLySubtransactionData *subtransactiondata;
1087 : :
1088 [ - + ]: 6 : Assert(explicit_subtransactions != NIL);
1089 : :
1090 [ + - ]: 6 : ereport(WARNING,
1091 : : (errmsg("forcibly aborting a subtransaction that has not been exited")));
1092 : :
1093 : 6 : RollbackAndReleaseCurrentSubTransaction();
1094 : :
1095 : 6 : subtransactiondata = (PLySubtransactionData *) linitial(explicit_subtransactions);
1096 : 6 : explicit_subtransactions = list_delete_first(explicit_subtransactions);
1097 : :
1098 : 6 : MemoryContextSwitchTo(subtransactiondata->oldcontext);
1099 : 6 : CurrentResourceOwner = subtransactiondata->oldowner;
3083 tgl@sss.pgh.pa.us 1100 : 6 : pfree(subtransactiondata);
1101 : : }
4501 peter_e@gmx.net 1102 : 553 : }
|
