src/pl/plpython/plpy_exec.c

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