plpy_cursorobject.h File Reference

#include "plpy_typeio.h"

Include dependency graph for plpy_cursorobject.h:

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

Go to the source code of this file.

Data Structures
struct	PLyCursorObject

Typedefs
typedef struct PLyCursorObject	PLyCursorObject

Functions
void	PLy_cursor_init_type (void)
PyObject *	PLy_cursor (PyObject *self, PyObject *args)
PyObject *	PLy_cursor_plan (PyObject *ob, PyObject *args)

Typedef Documentation

PLyCursorObject

typedef struct PLyCursorObject PLyCursorObject

Function Documentation

PLy_cursor()

PyObject * PLy_cursor	(	PyObject *	self,
		PyObject *	args
	)

Definition at line 56 of file plpy_cursorobject.c.

{
    char       *query;
    PyObject   *plan;
    PyObject   *planargs = NULL;
 
    if (PyArg_ParseTuple(args, "s", &query))
        return PLy_cursor_query(query);
 
    PyErr_Clear();
 
    if (PyArg_ParseTuple(args, "O|O", &plan, &planargs))
        return PLy_cursor_plan(plan, planargs);
 
    PLy_exception_set(PLy_exc_error, "plpy.cursor expected a query or a plan");
    return NULL;
}

References generate_unaccent_rules::args, plan, PLy_cursor_plan(), PLy_cursor_query(), PLy_exc_error, and PLy_exception_set().

PLy_cursor_init_type()

void PLy_cursor_init_type

(

void

)

Definition at line 49 of file plpy_cursorobject.c.

{
    if (PyType_Ready(&PLy_CursorType) < 0)
        elog(ERROR, "could not initialize PLy_CursorType");
}

References elog, ERROR, and PLy_CursorType.

Referenced by PLy_init_plpy().

PLy_cursor_plan()

PyObject * PLy_cursor_plan	(	PyObject *	ob,
		PyObject *	args
	)

Definition at line 139 of file plpy_cursorobject.c.

{
    PLyCursorObject *cursor;
    volatile int nargs;
    PLyPlanObject *plan;
    PLyExecutionContext *exec_ctx = PLy_current_execution_context();
    volatile MemoryContext oldcontext;
    volatile ResourceOwner oldowner;
 
    if (args)
    {
        if (!PySequence_Check(args) || PyUnicode_Check(args))
        {
            PLy_exception_set(PyExc_TypeError, "plpy.cursor takes a sequence as its second argument");
            return NULL;
        }
        nargs = PySequence_Length(args);
    }
    else
        nargs = 0;
 
    plan = (PLyPlanObject *) ob;
 
    if (nargs != plan->nargs)
    {
        char       *sv;
        PyObject   *so = PyObject_Str(args);
 
        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;
    }
 
    if ((cursor = PyObject_New(PLyCursorObject, &PLy_CursorType)) == NULL)
        return NULL;
    cursor->portalname = NULL;
    cursor->closed = false;
    cursor->mcxt = AllocSetContextCreate(TopMemoryContext,
                                         "PL/Python cursor context",
                                         ALLOCSET_DEFAULT_SIZES);
 
    /* Initialize for converting result tuples to Python */
    PLy_input_setup_func(&cursor->result, cursor->mcxt,
                         RECORDOID, -1,
                         exec_ctx->curr_proc);
 
    oldcontext = CurrentMemoryContext;
    oldowner = CurrentResourceOwner;
 
    PLy_spi_subtransaction_begin(oldcontext, oldowner);
 
    PG_TRY();
    {
        Portal      portal;
        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(args, 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);
 
        portal = SPI_cursor_open(NULL, plan->plan, values, nulls,
                                 exec_ctx->curr_proc->fn_readonly);
        if (portal == NULL)
            elog(ERROR, "SPI_cursor_open() failed: %s",
                 SPI_result_code_string(SPI_result));
 
        cursor->portalname = MemoryContextStrdup(cursor->mcxt, portal->name);
 
        PinPortal(portal);
 
        MemoryContextDelete(tmpcontext);
        PLy_spi_subtransaction_commit(oldcontext, oldowner);
    }
    PG_CATCH();
    {
        Py_DECREF(cursor);
        /* Subtransaction abort will remove the tmpcontext */
        PLy_spi_subtransaction_abort(oldcontext, oldowner);
        return NULL;
    }
    PG_END_TRY();
 
    Assert(cursor->portalname != NULL);
    return (PyObject *) cursor;
}

References ALLOCSET_DEFAULT_SIZES, ALLOCSET_SMALL_SIZES, AllocSetContextCreate, arg, generate_unaccent_rules::args, Assert, PLyExecutionContext::curr_proc, CurrentMemoryContext, CurrentResourceOwner, CurTransactionContext, elog, ERROR, PLyProcedure::fn_readonly, j, MemoryContextDelete(), MemoryContextStrdup(), MemoryContextSwitchTo(), PortalData::name, palloc(), PG_CATCH, PG_END_TRY, PG_FINALLY, PG_TRY, PinPortal(), plan, PLy_current_execution_context(), PLy_CursorType, PLy_elog, PLy_exception_set(), PLy_exception_set_plural(), PLy_input_setup_func(), PLy_output_convert(), PLy_spi_subtransaction_abort(), PLy_spi_subtransaction_begin(), PLy_spi_subtransaction_commit(), PLyUnicode_AsString(), SPI_cursor_open(), SPI_result, SPI_result_code_string(), TopMemoryContext, and values.

Referenced by PLy_cursor(), and PLy_plan_cursor().