plpy_exec.h File Reference

#include "plpy_procedure.h"

Include dependency graph for plpy_exec.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
Datum	PLy_exec_function (FunctionCallInfo fcinfo, PLyProcedureCache *pcache)
HeapTuple	PLy_exec_trigger (FunctionCallInfo fcinfo, PLyProcedure *proc)
void	PLy_exec_event_trigger (FunctionCallInfo fcinfo, PLyProcedure *proc)
void	PLy_function_cleanup_srfstate (PLyProcedureCache *pcache)

Function Documentation

PLy_exec_event_trigger()

void PLy_exec_event_trigger ( FunctionCallInfo  fcinfo, PLyProcedure *  proc  )

extern

Definition at line 504 of file plpy_exec.c.

{
    EventTriggerData *tdata;
    PyObject   *volatile pltdata = NULL;
 
    Assert(CALLED_AS_EVENT_TRIGGER(fcinfo));
    tdata = (EventTriggerData *) fcinfo->context;
 
    PG_TRY();
    {
        PyObject   *pltevent,
                   *plttag;
 
        pltdata = PyDict_New();
        if (!pltdata)
            PLy_elog(ERROR, NULL);
 
        pltevent = PLyUnicode_FromString(tdata->event);
        PyDict_SetItemString(pltdata, "event", pltevent);
        Py_DECREF(pltevent);
 
        plttag = PLyUnicode_FromString(GetCommandTagName(tdata->tag));
        PyDict_SetItemString(pltdata, "tag", plttag);
        Py_DECREF(plttag);
 
        PLy_procedure_call(proc, "TD", pltdata);
 
        if (SPI_finish() != SPI_OK_FINISH)
            elog(ERROR, "SPI_finish() failed");
    }
    PG_FINALLY();
    {
        Py_XDECREF(pltdata);
    }
    PG_END_TRY();
}

References Assert, CALLED_AS_EVENT_TRIGGER, FunctionCallInfoBaseData::context, elog, ERROR, fb(), GetCommandTagName(), PG_END_TRY, PG_FINALLY, PG_TRY, PLy_elog, PLy_procedure_call(), PLyUnicode_FromString(), SPI_finish(), and SPI_OK_FINISH.

Referenced by plpython3_call_handler().

PLy_exec_function()

Datum PLy_exec_function ( FunctionCallInfo  fcinfo, PLyProcedureCache *  pcache  )

extern

Definition at line 41 of file plpy_exec.c.

{
    PLyProcedure *proc = pcache->proc;
    bool        is_setof = proc->is_setof;
    ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
    Datum       rv;
    PyObject   *volatile plargs = NULL;
    PyObject   *volatile plrv = NULL;
    PLySRFState *volatile srfstate = NULL;
    ErrorContextCallback plerrcontext;
 
    /*
     * If the function is called recursively, we must push outer-level
     * arguments into the stack.  This must be immediately before the PG_TRY
     * to ensure that the corresponding pop happens.
     */
    PLy_global_args_push(proc);
 
    PG_TRY();
    {
        if (is_setof)
        {
            /*
             * PL/Python returns sets in ValuePerCall mode, so the handler is
             * invoked once per result row.  Across those calls we keep the
             * iterator and saved arguments in the per-call-site cache
             * (pcache->srfstate); a NULL srfstate means this is the first
             * call of a new iteration, so we must set up that state now.
             */
            if (pcache->srfstate == NULL)
            {
                if (!rsi || !IsA(rsi, ReturnSetInfo) ||
                    (rsi->allowedModes & SFRM_ValuePerCall) == 0)
                {
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("unsupported set function return mode"),
                             errdetail("PL/Python set-returning functions only support returning one value per call.")));
                }
                rsi->returnMode = SFRM_ValuePerCall;
 
                pcache->srfstate = (PLySRFState *)
                    MemoryContextAllocZero(pcache->fcontext, sizeof(PLySRFState));
 
                /*
                 * Register a shutdown callback so that the iterator state is
                 * released if execution is abandoned before the iterator is
                 * exhausted.  We'll unregister it again on normal completion.
                 */
                RegisterExprContextCallback(rsi->econtext,
                                            ShutdownPLyFunction,
                                            PointerGetDatum(pcache));
                pcache->shutdown_reg = true;
            }
 
            srfstate = pcache->srfstate;
        }
 
        if (srfstate == NULL || srfstate->iter == NULL)
        {
            /*
             * Non-SETOF function or first time for SETOF function: build
             * args, then actually execute the function.
             */
            plargs = PLy_function_build_args(fcinfo, proc);
            plrv = PLy_procedure_call(proc, "args", plargs);
            Assert(plrv != NULL);
        }
        else
        {
            /*
             * Second or later call for a SETOF function: restore arguments in
             * globals dict to what they were when we left off.  We must do
             * this in case multiple evaluations of the same SETOF function
             * are interleaved.  It's a bit annoying, since the iterator may
             * not look at the arguments at all, but we have no way to know
             * that.  Fortunately this isn't terribly expensive.
             */
            if (srfstate->savedargs)
                PLy_function_restore_args(proc, srfstate->savedargs);
            srfstate->savedargs = NULL; /* deleted by restore_args */
        }
 
        /*
         * If it returns a set, call the iterator to get the next return item.
         * We stay in the SPI context while doing this, because PyIter_Next()
         * calls back into Python code which might contain SPI calls.
         */
        if (is_setof)
        {
            if (srfstate->iter == NULL)
            {
                /* First time -- make iterator out of returned object */
                srfstate->iter = PyObject_GetIter(plrv);
 
                Py_DECREF(plrv);
                plrv = NULL;
 
                if (srfstate->iter == NULL)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("returned object cannot be iterated"),
                             errdetail("PL/Python set-returning functions must return an iterable object.")));
            }
 
            /* Fetch next from iterator */
            plrv = PyIter_Next(srfstate->iter);
            if (plrv == NULL)
            {
                /* Iterator is exhausted or error happened */
                bool        has_error = (PyErr_Occurred() != NULL);
 
                Py_DECREF(srfstate->iter);
                srfstate->iter = NULL;
 
                if (has_error)
                    PLy_elog(ERROR, "error fetching next item from iterator");
 
                /* Pass a null through the data-returning steps below */
                Py_INCREF(Py_None);
                plrv = Py_None;
            }
            else
            {
                /*
                 * This won't be last call, so save argument values.  We do
                 * this again each time in case the iterator is changing those
                 * values.
                 */
                srfstate->savedargs = PLy_function_save_args(proc);
            }
        }
 
        /*
         * Disconnect from SPI manager and then create the return values datum
         * (if the input function does a palloc for it this must not be
         * allocated in the SPI memory context because SPI_finish would free
         * it).
         */
        if (SPI_finish() != SPI_OK_FINISH)
            elog(ERROR, "SPI_finish failed");
 
        plerrcontext.callback = plpython_return_error_callback;
        plerrcontext.previous = error_context_stack;
        error_context_stack = &plerrcontext;
 
        /*
         * For a procedure or function declared to return void, the Python
         * return value must be None. For void-returning functions, we also
         * treat a None return value as a special "void datum" rather than
         * NULL (as is the case for non-void-returning functions).
         */
        if (proc->result.typoid == VOIDOID)
        {
            if (plrv != Py_None)
            {
                if (proc->is_procedure)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("PL/Python procedure did not return None")));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("PL/Python function with return type \"void\" did not return None")));
            }
 
            fcinfo->isnull = false;
            rv = (Datum) 0;
        }
        else if (plrv == Py_None &&
                 srfstate && srfstate->iter == NULL)
        {
            /*
             * In a SETOF function, the iteration-ending null isn't a real
             * value; don't pass it through the input function, which might
             * complain.
             */
            fcinfo->isnull = true;
            rv = (Datum) 0;
        }
        else
        {
            /*
             * Normal conversion of result.  However, if the result is of type
             * RECORD, we have to set up for that each time through, since it
             * might be different from last time.
             */
            if (proc->result.typoid == RECORDOID)
            {
                TupleDesc   desc;
 
                if (get_call_result_type(fcinfo, NULL, &desc) != TYPEFUNC_COMPOSITE)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("function returning record called in context "
                                    "that cannot accept type record")));
                PLy_output_setup_record(&proc->result, desc, proc);
            }
 
            rv = PLy_output_convert(&proc->result, plrv,
                                    &fcinfo->isnull);
        }
    }
    PG_CATCH();
    {
        /* Pop old arguments from the stack if they were pushed above */
        PLy_global_args_pop(proc);
 
        Py_XDECREF(plargs);
        Py_XDECREF(plrv);
 
        /*
         * If we are erroring out of a SRF, clean up its state immediately.
         * ShutdownPLyFunction will not be called on abort, and the
         * memory-context callback only fires when the FmgrInfo's context is
         * torn down.  Releasing the Python references promptly avoids leaking
         * them if teardown is delayed, and clearing pcache->srfstate ensures
         * that if we reuse the pcache we won't mistake this for an iteration
         * still in progress.
         */
        PLy_function_cleanup_srfstate(pcache);
 
        PG_RE_THROW();
    }
    PG_END_TRY();
 
    error_context_stack = plerrcontext.previous;
 
    /* Pop old arguments from the stack if they were pushed above */
    PLy_global_args_pop(proc);
 
    Py_XDECREF(plargs);
    Py_DECREF(plrv);
 
    if (srfstate)
    {
        /* We're in a SRF, signal done-or-not via rsi->isDone */
        if (srfstate->iter == NULL)
        {
            /*
             * Iterator exhausted.  Unregister the shutdown callback since
             * we're done normally, then clean up srfstate.  (srfstate->iter
             * is already NULL here, so the cleanup just frees the struct.)
             */
            if (pcache->shutdown_reg)
            {
                UnregisterExprContextCallback(rsi->econtext,
                                              ShutdownPLyFunction,
                                              PointerGetDatum(pcache));
                pcache->shutdown_reg = false;
            }
            PLy_function_cleanup_srfstate(pcache);
 
            rsi->isDone = ExprEndResult;
            fcinfo->isnull = true;
            return (Datum) 0;
        }
        else
        {
            rsi->isDone = ExprMultipleResult;
            return rv;
        }
    }
 
    /* Plain function, just return the Datum value (possibly null) */
    return rv;
}

References ReturnSetInfo::allowedModes, Assert, ReturnSetInfo::econtext, elog, ereport, errcode(), errdetail(), errmsg, ERROR, error_context_stack, ExprEndResult, ExprMultipleResult, fb(), get_call_result_type(), PLyProcedure::is_procedure, PLyProcedure::is_setof, IsA, ReturnSetInfo::isDone, FunctionCallInfoBaseData::isnull, PLySRFState::iter, MemoryContextAllocZero(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, plpython_return_error_callback(), PLy_elog, PLy_function_build_args(), PLy_function_cleanup_srfstate(), PLy_function_restore_args(), PLy_function_save_args(), PLy_global_args_pop(), PLy_global_args_push(), PLy_output_convert(), PLy_output_setup_record(), PLy_procedure_call(), PointerGetDatum, ErrorContextCallback::previous, RegisterExprContextCallback(), PLyProcedure::result, FunctionCallInfoBaseData::resultinfo, ReturnSetInfo::returnMode, PLySRFState::savedargs, SFRM_ValuePerCall, ShutdownPLyFunction(), SPI_finish(), SPI_OK_FINISH, TYPEFUNC_COMPOSITE, PLyObToDatum::typoid, and UnregisterExprContextCallback().

Referenced by plpython3_call_handler(), and plpython3_inline_handler().

PLy_exec_trigger()

HeapTuple PLy_exec_trigger ( FunctionCallInfo  fcinfo, PLyProcedure *  proc  )

extern

Definition at line 389 of file plpy_exec.c.

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

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

Referenced by plpython3_call_handler().

PLy_function_cleanup_srfstate()

void PLy_function_cleanup_srfstate ( PLyProcedureCache *  pcache )

extern

Definition at line 357 of file plpy_exec.c.

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

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

Referenced by PLy_exec_function(), RemovePLyProcedureCache(), and ShutdownPLyFunction().