plpy_spi.h File Reference

#include "plpython.h"
#include "utils/resowner.h"

Include dependency graph for plpy_spi.h:

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

Go to the source code of this file.

Data Structures
struct	PLyExceptionEntry

Typedefs
typedef struct PLyExceptionEntry	PLyExceptionEntry

Functions
PyObject *	PLy_spi_prepare (PyObject *self, PyObject *args)
PyObject *	PLy_spi_execute (PyObject *self, PyObject *args)
PyObject *	PLy_spi_execute_plan (PyObject *ob, PyObject *list, long limit)
PyObject *	PLy_commit (PyObject *self, PyObject *args)
PyObject *	PLy_rollback (PyObject *self, PyObject *args)
void	PLy_spi_subtransaction_begin (MemoryContext oldcontext, ResourceOwner oldowner)
void	PLy_spi_subtransaction_commit (MemoryContext oldcontext, ResourceOwner oldowner)
void	PLy_spi_subtransaction_abort (MemoryContext oldcontext, ResourceOwner oldowner)

Typedef Documentation

PLyExceptionEntry

typedef struct PLyExceptionEntry PLyExceptionEntry

Function Documentation

PLy_commit()

PyObject * PLy_commit ( PyObject *  self, PyObject *  args  )

extern

Definition at line 448 of file plpy_spi.c.

{
    MemoryContext oldcontext = CurrentMemoryContext;
    PLyExecutionContext *exec_ctx = PLy_current_execution_context();
 
    PG_TRY();
    {
        SPI_commit();
 
        /* was cleared at transaction end, reset pointer */
        exec_ctx->scratch_ctx = NULL;
    }
    PG_CATCH();
    {
        ErrorData  *edata;
        PLyExceptionEntry *entry;
        PyObject   *exc;
 
        /* Save error info */
        MemoryContextSwitchTo(oldcontext);
        edata = CopyErrorData();
        FlushErrorState();
 
        /* was cleared at transaction end, reset pointer */
        exec_ctx->scratch_ctx = NULL;
 
        /* Look up the correct exception */
        entry = hash_search(PLy_spi_exceptions, &(edata->sqlerrcode),
                            HASH_FIND, NULL);
 
        /*
         * This could be a custom error code, if that's the case fallback to
         * SPIError
         */
        exc = entry ? entry->exc : PLy_exc_spi_error;
        /* Make Python raise the exception */
        PLy_spi_exception_set(exc, edata);
        FreeErrorData(edata);
 
        return NULL;
    }
    PG_END_TRY();
 
    Py_RETURN_NONE;
}

References CopyErrorData(), CurrentMemoryContext, PLyExceptionEntry::exc, fb(), FlushErrorState(), FreeErrorData(), HASH_FIND, hash_search(), MemoryContextSwitchTo(), PG_CATCH, PG_END_TRY, PG_TRY, PLy_current_execution_context(), PLy_exc_spi_error, PLy_spi_exception_set(), PLy_spi_exceptions, and SPI_commit().

PLy_rollback()

PyObject * PLy_rollback ( PyObject *  self, PyObject *  args  )

extern

Definition at line 495 of file plpy_spi.c.

{
    MemoryContext oldcontext = CurrentMemoryContext;
    PLyExecutionContext *exec_ctx = PLy_current_execution_context();
 
    PG_TRY();
    {
        SPI_rollback();
 
        /* was cleared at transaction end, reset pointer */
        exec_ctx->scratch_ctx = NULL;
    }
    PG_CATCH();
    {
        ErrorData  *edata;
        PLyExceptionEntry *entry;
        PyObject   *exc;
 
        /* Save error info */
        MemoryContextSwitchTo(oldcontext);
        edata = CopyErrorData();
        FlushErrorState();
 
        /* was cleared at transaction end, reset pointer */
        exec_ctx->scratch_ctx = NULL;
 
        /* Look up the correct exception */
        entry = hash_search(PLy_spi_exceptions, &(edata->sqlerrcode),
                            HASH_FIND, NULL);
 
        /*
         * This could be a custom error code, if that's the case fallback to
         * SPIError
         */
        exc = entry ? entry->exc : PLy_exc_spi_error;
        /* Make Python raise the exception */
        PLy_spi_exception_set(exc, edata);
        FreeErrorData(edata);
 
        return NULL;
    }
    PG_END_TRY();
 
    Py_RETURN_NONE;
}

References CopyErrorData(), CurrentMemoryContext, PLyExceptionEntry::exc, fb(), FlushErrorState(), FreeErrorData(), HASH_FIND, hash_search(), MemoryContextSwitchTo(), PG_CATCH, PG_END_TRY, PG_TRY, PLy_current_execution_context(), PLy_exc_spi_error, PLy_spi_exception_set(), PLy_spi_exceptions, and SPI_rollback().

PLy_spi_execute()

PyObject * PLy_spi_execute ( PyObject *  self, PyObject *  args  )

extern

Definition at line 152 of file plpy_spi.c.

{
    char       *query;
    PyObject   *plan;
    PyObject   *list = NULL;
    long        limit = 0;
 
    if (PyArg_ParseTuple(args, "s|l", &query, &limit))
        return PLy_spi_execute_query(query, limit);
 
    PyErr_Clear();
 
    if (PyArg_ParseTuple(args, "O|Ol", &plan, &list, &limit) &&
        is_PLyPlanObject(plan))
        return PLy_spi_execute_plan(plan, list, limit);
 
    PLy_exception_set(PLy_exc_error, "plpy.execute expected a query or a plan");
    return NULL;
}

References fb(), is_PLyPlanObject(), plan, PLy_exc_error, PLy_exception_set(), PLy_spi_execute_plan(), and PLy_spi_execute_query().

PLy_spi_execute_plan()

PyObject * PLy_spi_execute_plan ( PyObject *  ob, PyObject *  list, long  limit  )

extern

Definition at line 173 of file plpy_spi.c.

{
    volatile int nargs;
    int         rv;
    PLyPlanObject *plan;
    volatile MemoryContext oldcontext;
    volatile ResourceOwner oldowner;
    PyObject   *ret;
 
    if (list != NULL)
    {
        if (!PySequence_Check(list) || PyUnicode_Check(list))
        {
            PLy_exception_set(PyExc_TypeError, "plpy.execute takes a sequence as its second argument");
            return NULL;
        }
        nargs = PySequence_Length(list);
    }
    else
        nargs = 0;
 
    plan = (PLyPlanObject *) ob;
 
    if (nargs != plan->nargs)
    {
        char       *sv;
        PyObject   *so = PyObject_Str(list);
 
        if (!so)
            PLy_elog(ERROR, "could not execute plan");
        sv = PLyUnicode_AsString(so);
        PLy_exception_set_plural(PyExc_TypeError,
                                 "Expected sequence of %d argument, got %d: %s",
                                 "Expected sequence of %d arguments, got %d: %s",
                                 plan->nargs,
                                 plan->nargs, nargs, sv);
        Py_DECREF(so);
 
        return NULL;
    }
 
    oldcontext = CurrentMemoryContext;
    oldowner = CurrentResourceOwner;
 
    PLy_spi_subtransaction_begin(oldcontext, oldowner);
 
    PG_TRY();
    {
        PLyExecutionContext *exec_ctx = PLy_current_execution_context();
        MemoryContext tmpcontext;
        Datum      *volatile values;
        char       *volatile nulls;
        volatile int j;
 
        /*
         * Converted arguments and associated cruft will be in this context,
         * which is local to our subtransaction.
         */
        tmpcontext = AllocSetContextCreate(CurTransactionContext,
                                           "PL/Python temporary context",
                                           ALLOCSET_SMALL_SIZES);
        MemoryContextSwitchTo(tmpcontext);
 
        if (nargs > 0)
        {
            values = (Datum *) palloc(nargs * sizeof(Datum));
            nulls = (char *) palloc(nargs * sizeof(char));
        }
        else
        {
            values = NULL;
            nulls = NULL;
        }
 
        for (j = 0; j < nargs; j++)
        {
            PLyObToDatum *arg = &plan->args[j];
            PyObject   *elem;
 
            elem = PySequence_GetItem(list, j);
            PG_TRY(2);
            {
                bool        isnull;
 
                values[j] = PLy_output_convert(arg, elem, &isnull);
                nulls[j] = isnull ? 'n' : ' ';
            }
            PG_FINALLY(2);
            {
                Py_DECREF(elem);
            }
            PG_END_TRY(2);
        }
 
        MemoryContextSwitchTo(oldcontext);
 
        rv = SPI_execute_plan(plan->plan, values, nulls,
                              exec_ctx->curr_proc->fn_readonly, limit);
        ret = PLy_spi_execute_fetch_result(SPI_tuptable, SPI_processed, rv);
 
        MemoryContextDelete(tmpcontext);
        PLy_spi_subtransaction_commit(oldcontext, oldowner);
    }
    PG_CATCH();
    {
        /* Subtransaction abort will remove the tmpcontext */
        PLy_spi_subtransaction_abort(oldcontext, oldowner);
        return NULL;
    }
    PG_END_TRY();
 
    if (rv < 0)
    {
        PLy_exception_set(PLy_exc_spi_error,
                          "SPI_execute_plan failed: %s",
                          SPI_result_code_string(rv));
        return NULL;
    }
 
    return ret;
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, arg, CurrentMemoryContext, CurrentResourceOwner, CurTransactionContext, ERROR, fb(), j, MemoryContextDelete(), MemoryContextSwitchTo(), palloc(), PG_CATCH, PG_END_TRY, PG_FINALLY, PG_TRY, plan, PLy_current_execution_context(), PLy_elog, PLy_exc_spi_error, PLy_exception_set(), PLy_exception_set_plural(), PLy_output_convert(), PLy_spi_execute_fetch_result(), PLy_spi_subtransaction_abort(), PLy_spi_subtransaction_begin(), PLy_spi_subtransaction_commit(), PLyUnicode_AsString(), SPI_execute_plan(), SPI_processed, SPI_result_code_string(), SPI_tuptable, and values.

Referenced by PLy_plan_execute(), and PLy_spi_execute().

PLy_spi_prepare()

PyObject * PLy_spi_prepare ( PyObject *  self, PyObject *  args  )

extern

Definition at line 37 of file plpy_spi.c.

{
    PLyPlanObject *plan;
    PyObject   *list = NULL;
    PyObject   *volatile optr = NULL;
    char       *query;
    PLyExecutionContext *exec_ctx = PLy_current_execution_context();
    volatile MemoryContext oldcontext;
    volatile ResourceOwner oldowner;
    volatile int nargs;
 
    if (!PyArg_ParseTuple(args, "s|O:prepare", &query, &list))
        return NULL;
 
    if (list && (!PySequence_Check(list)))
    {
        PLy_exception_set(PyExc_TypeError,
                          "second argument of plpy.prepare must be a sequence");
        return NULL;
    }
 
    if ((plan = (PLyPlanObject *) PLy_plan_new()) == NULL)
        return NULL;
 
    plan->mcxt = AllocSetContextCreate(TopMemoryContext,
                                       "PL/Python plan context",
                                       ALLOCSET_DEFAULT_SIZES);
    oldcontext = MemoryContextSwitchTo(plan->mcxt);
 
    nargs = list ? PySequence_Length(list) : 0;
 
    plan->nargs = nargs;
    plan->types = nargs ? palloc0_array(Oid, nargs) : NULL;
    plan->args = nargs ? palloc0_array(PLyObToDatum, nargs) : NULL;
 
    MemoryContextSwitchTo(oldcontext);
 
    oldcontext = CurrentMemoryContext;
    oldowner = CurrentResourceOwner;
 
    PLy_spi_subtransaction_begin(oldcontext, oldowner);
 
    PG_TRY();
    {
        int         i;
 
        for (i = 0; i < nargs; i++)
        {
            char       *sptr;
            Oid         typeId;
            int32       typmod;
 
            optr = PySequence_GetItem(list, i);
            if (PyUnicode_Check(optr))
                sptr = PLyUnicode_AsString(optr);
            else
            {
                ereport(ERROR,
                        (errmsg("plpy.prepare: type name at ordinal position %d is not a string", i)));
                sptr = NULL;    /* keep compiler quiet */
            }
 
            /********************************************************
             * Resolve argument type names and then look them up by
             * oid in the system cache, and remember the required
             *information for input conversion.
             ********************************************************/
 
            (void) parseTypeString(sptr, &typeId, &typmod, NULL);
 
            Py_DECREF(optr);
 
            /*
             * set optr to NULL, so we won't try to unref it again in case of
             * an error
             */
            optr = NULL;
 
            plan->types[i] = typeId;
            PLy_output_setup_func(&plan->args[i], plan->mcxt,
                                  typeId, typmod,
                                  exec_ctx->curr_proc);
        }
 
        pg_verifymbstr(query, strlen(query), false);
        plan->plan = SPI_prepare(query, plan->nargs, plan->types);
        if (plan->plan == NULL)
            elog(ERROR, "SPI_prepare failed: %s",
                 SPI_result_code_string(SPI_result));
 
        /* transfer plan from procCxt to topCxt */
        if (SPI_keepplan(plan->plan))
            elog(ERROR, "SPI_keepplan failed");
 
        PLy_spi_subtransaction_commit(oldcontext, oldowner);
    }
    PG_CATCH();
    {
        Py_DECREF(plan);
        Py_XDECREF(optr);
 
        PLy_spi_subtransaction_abort(oldcontext, oldowner);
        return NULL;
    }
    PG_END_TRY();
 
    Assert(plan->plan != NULL);
    return (PyObject *) plan;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, CurrentMemoryContext, CurrentResourceOwner, elog, ereport, errmsg, ERROR, fb(), i, MemoryContextSwitchTo(), palloc0_array, parseTypeString(), PG_CATCH, PG_END_TRY, PG_TRY, pg_verifymbstr(), plan, PLy_current_execution_context(), PLy_exception_set(), PLy_output_setup_func(), PLy_plan_new(), PLy_spi_subtransaction_abort(), PLy_spi_subtransaction_begin(), PLy_spi_subtransaction_commit(), PLyUnicode_AsString(), SPI_keepplan(), SPI_prepare(), SPI_result, SPI_result_code_string(), and TopMemoryContext.

PLy_spi_subtransaction_abort()

void PLy_spi_subtransaction_abort ( MemoryContext  oldcontext, ResourceOwner  oldowner  )

extern

Definition at line 584 of file plpy_spi.c.

{
    ErrorData  *edata;
    PLyExceptionEntry *entry;
    PyObject   *exc;
 
    /* Save error info */
    MemoryContextSwitchTo(oldcontext);
    edata = CopyErrorData();
    FlushErrorState();
 
    /* Abort the inner transaction */
    RollbackAndReleaseCurrentSubTransaction();
    MemoryContextSwitchTo(oldcontext);
    CurrentResourceOwner = oldowner;
 
    /* Look up the correct exception */
    entry = hash_search(PLy_spi_exceptions, &(edata->sqlerrcode),
                        HASH_FIND, NULL);
 
    /*
     * This could be a custom error code, if that's the case fallback to
     * SPIError
     */
    exc = entry ? entry->exc : PLy_exc_spi_error;
    /* Make Python raise the exception */
    PLy_spi_exception_set(exc, edata);
    FreeErrorData(edata);
}

References CopyErrorData(), CurrentResourceOwner, PLyExceptionEntry::exc, fb(), FlushErrorState(), FreeErrorData(), HASH_FIND, hash_search(), MemoryContextSwitchTo(), PLy_exc_spi_error, PLy_spi_exception_set(), PLy_spi_exceptions, and RollbackAndReleaseCurrentSubTransaction().

Referenced by PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_cursor_plan(), PLy_cursor_query(), PLy_spi_execute_plan(), PLy_spi_execute_query(), and PLy_spi_prepare().

PLy_spi_subtransaction_begin()

void PLy_spi_subtransaction_begin ( MemoryContext  oldcontext, ResourceOwner  oldowner  )

extern

Definition at line 567 of file plpy_spi.c.

{
    BeginInternalSubTransaction(NULL);
    /* Want to run inside function's memory context */
    MemoryContextSwitchTo(oldcontext);
}

References BeginInternalSubTransaction(), fb(), and MemoryContextSwitchTo().

Referenced by PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_cursor_plan(), PLy_cursor_query(), PLy_spi_execute_plan(), PLy_spi_execute_query(), and PLy_spi_prepare().

PLy_spi_subtransaction_commit()

void PLy_spi_subtransaction_commit ( MemoryContext  oldcontext, ResourceOwner  oldowner  )

extern

Definition at line 575 of file plpy_spi.c.

{
    /* Commit the inner transaction, return to outer xact context */
    ReleaseCurrentSubTransaction();
    MemoryContextSwitchTo(oldcontext);
    CurrentResourceOwner = oldowner;
}

References CurrentResourceOwner, MemoryContextSwitchTo(), and ReleaseCurrentSubTransaction().

Referenced by PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_cursor_plan(), PLy_cursor_query(), PLy_spi_execute_plan(), PLy_spi_execute_query(), and PLy_spi_prepare().