mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-09-13 23:19:35 +02:00
70ec3f1f8f
Instead of
plan = plpy.prepare(...)
res = plpy.execute(plan, ...)
you can now write
plan = plpy.prepare(...)
res = plan.execute(...)
or even
res = plpy.prepare(...).execute(...)
and similarly for the cursor() method.
This is more in object oriented style, and makes the hybrid nature of
the existing execute() function less confusing.
Reviewed-by: Andrew Dunstan <andrew.dunstan@2ndquadrant.com>
156 lines
3.0 KiB
C
156 lines
3.0 KiB
C
/*
|
|
* the PLyPlan class
|
|
*
|
|
* src/pl/plpython/plpy_planobject.c
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
#include "plpython.h"
|
|
|
|
#include "plpy_planobject.h"
|
|
|
|
#include "plpy_cursorobject.h"
|
|
#include "plpy_elog.h"
|
|
#include "plpy_spi.h"
|
|
#include "utils/memutils.h"
|
|
|
|
|
|
static void PLy_plan_dealloc(PyObject *arg);
|
|
static PyObject *PLy_plan_cursor(PyObject *self, PyObject *args);
|
|
static PyObject *PLy_plan_execute(PyObject *self, PyObject *args);
|
|
static PyObject *PLy_plan_status(PyObject *self, PyObject *args);
|
|
|
|
static char PLy_plan_doc[] = {
|
|
"Store a PostgreSQL plan"
|
|
};
|
|
|
|
static PyMethodDef PLy_plan_methods[] = {
|
|
{"cursor", PLy_plan_cursor, METH_VARARGS, NULL},
|
|
{"execute", PLy_plan_execute, METH_VARARGS, NULL},
|
|
{"status", PLy_plan_status, METH_VARARGS, NULL},
|
|
{NULL, NULL, 0, NULL}
|
|
};
|
|
|
|
static PyTypeObject PLy_PlanType = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"PLyPlan", /* tp_name */
|
|
sizeof(PLyPlanObject), /* tp_size */
|
|
0, /* tp_itemsize */
|
|
|
|
/*
|
|
* methods
|
|
*/
|
|
PLy_plan_dealloc, /* tp_dealloc */
|
|
0, /* tp_print */
|
|
0, /* tp_getattr */
|
|
0, /* tp_setattr */
|
|
0, /* tp_compare */
|
|
0, /* tp_repr */
|
|
0, /* tp_as_number */
|
|
0, /* tp_as_sequence */
|
|
0, /* tp_as_mapping */
|
|
0, /* tp_hash */
|
|
0, /* tp_call */
|
|
0, /* tp_str */
|
|
0, /* tp_getattro */
|
|
0, /* tp_setattro */
|
|
0, /* tp_as_buffer */
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
|
|
PLy_plan_doc, /* tp_doc */
|
|
0, /* tp_traverse */
|
|
0, /* tp_clear */
|
|
0, /* tp_richcompare */
|
|
0, /* tp_weaklistoffset */
|
|
0, /* tp_iter */
|
|
0, /* tp_iternext */
|
|
PLy_plan_methods, /* tp_tpmethods */
|
|
};
|
|
|
|
void
|
|
PLy_plan_init_type(void)
|
|
{
|
|
if (PyType_Ready(&PLy_PlanType) < 0)
|
|
elog(ERROR, "could not initialize PLy_PlanType");
|
|
}
|
|
|
|
PyObject *
|
|
PLy_plan_new(void)
|
|
{
|
|
PLyPlanObject *ob;
|
|
|
|
if ((ob = PyObject_New(PLyPlanObject, &PLy_PlanType)) == NULL)
|
|
return NULL;
|
|
|
|
ob->plan = NULL;
|
|
ob->nargs = 0;
|
|
ob->types = NULL;
|
|
ob->values = NULL;
|
|
ob->args = NULL;
|
|
ob->mcxt = NULL;
|
|
|
|
return (PyObject *) ob;
|
|
}
|
|
|
|
bool
|
|
is_PLyPlanObject(PyObject *ob)
|
|
{
|
|
return ob->ob_type == &PLy_PlanType;
|
|
}
|
|
|
|
static void
|
|
PLy_plan_dealloc(PyObject *arg)
|
|
{
|
|
PLyPlanObject *ob = (PLyPlanObject *) arg;
|
|
|
|
if (ob->plan)
|
|
{
|
|
SPI_freeplan(ob->plan);
|
|
ob->plan = NULL;
|
|
}
|
|
if (ob->mcxt)
|
|
{
|
|
MemoryContextDelete(ob->mcxt);
|
|
ob->mcxt = NULL;
|
|
}
|
|
arg->ob_type->tp_free(arg);
|
|
}
|
|
|
|
|
|
static PyObject *
|
|
PLy_plan_cursor(PyObject *self, PyObject *args)
|
|
{
|
|
PyObject *planargs = NULL;
|
|
|
|
if (!PyArg_ParseTuple(args, "|O", &planargs))
|
|
return NULL;
|
|
|
|
return PLy_cursor_plan(self, planargs);
|
|
}
|
|
|
|
|
|
static PyObject *
|
|
PLy_plan_execute(PyObject *self, PyObject *args)
|
|
{
|
|
PyObject *list = NULL;
|
|
long limit = 0;
|
|
|
|
if (!PyArg_ParseTuple(args, "|Ol", &list, &limit))
|
|
return NULL;
|
|
|
|
return PLy_spi_execute_plan(self, list, limit);
|
|
}
|
|
|
|
|
|
static PyObject *
|
|
PLy_plan_status(PyObject *self, PyObject *args)
|
|
{
|
|
if (PyArg_ParseTuple(args, ":status"))
|
|
{
|
|
Py_INCREF(Py_True);
|
|
return Py_True;
|
|
/* return PyInt_FromLong(self->status); */
|
|
}
|
|
return NULL;
|
|
}
|