database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-06-16 06:01:02 +03:00
Code Activity

Prepare for Python "Limited API" in PL/Python

Browse Source 
Using the Python Limited API would allow building PL/Python against
any Python 3.x version and using another Python 3.x version at run
time.  This commit does not activate that, but it prepares the code to
only use APIs supported by the Limited API.

Implementation details:

- Convert static types to heap types
  (https://docs.python.org/3/howto/isolating-extensions.html#heap-types).

- Replace PyRun_String() with component functions.

- Replace PyList_SET_ITEM() with PyList_SetItem().

Reviewed-by: Jakob Egger <jakob@eggerapps.at>
Discussion: https://www.postgresql.org/message-id/flat/ee410de1-1e0b-4770-b125-eeefd4726a24@eisentraut.org
This commit is contained in:
Peter Eisentraut
2025-02-26 16:14:16 +01:00
parent 0e42d31b0b
commit c47e8df815
6 changed files with 177 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
src/pl/plpython/plpy_cursorobject.c
View File

@ -20,7 +20,7 @@
#include "utils/memutils.h" #include "utils/memutils.h"
static PyObject *PLy_cursor_query(const char *query); static PyObject *PLy_cursor_query(const char *query);
static void PLy_cursor_dealloc(PyObject *arg); static void PLy_cursor_dealloc(PLyCursorObject *self);
static PyObject *PLy_cursor_iternext(PyObject *self); static PyObject *PLy_cursor_iternext(PyObject *self);
static PyObject *PLy_cursor_fetch(PyObject *self, PyObject *args); static PyObject *PLy_cursor_fetch(PyObject *self, PyObject *args);
static PyObject *PLy_cursor_close(PyObject *self, PyObject *unused); static PyObject *PLy_cursor_close(PyObject *self, PyObject *unused);
@ -33,22 +33,43 @@ static PyMethodDef PLy_cursor_methods[] = {
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
static PyTypeObject PLy_CursorType = { static PyType_Slot PLyCursor_slots[] =
PyVarObject_HEAD_INIT(NULL, 0) {
.tp_name = "PLyCursor", {
.tp_basicsize = sizeof(PLyCursorObject), Py_tp_dealloc, PLy_cursor_dealloc
.tp_dealloc = PLy_cursor_dealloc, },
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, {
.tp_doc = PLy_cursor_doc, Py_tp_doc, (char *) PLy_cursor_doc
.tp_iter = PyObject_SelfIter, },
.tp_iternext = PLy_cursor_iternext, {
.tp_methods = PLy_cursor_methods, Py_tp_iter, PyObject_SelfIter
},
{
Py_tp_iternext, PLy_cursor_iternext
},
{
Py_tp_methods, PLy_cursor_methods
},
{
0, NULL
}
}; };
static PyType_Spec PLyCursor_spec =
{
.name = "PLyCursor",
.basicsize = sizeof(PLyCursorObject),
.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
.slots = PLyCursor_slots,
};
static PyTypeObject *PLy_CursorType;
void void
PLy_cursor_init_type(void) PLy_cursor_init_type(void)
{ {
if (PyType_Ready(&PLy_CursorType) < 0) PLy_CursorType = (PyTypeObject *) PyType_FromSpec(&PLyCursor_spec);
if (!PLy_CursorType)
elog(ERROR, "could not initialize PLy_CursorType"); elog(ERROR, "could not initialize PLy_CursorType");
} }
@ -80,7 +101,7 @@ PLy_cursor_query(const char *query)
volatile MemoryContext oldcontext; volatile MemoryContext oldcontext;
volatile ResourceOwner oldowner; volatile ResourceOwner oldowner;
if ((cursor = PyObject_New(PLyCursorObject, &PLy_CursorType)) == NULL) if ((cursor = PyObject_New(PLyCursorObject, PLy_CursorType)) == NULL)
return NULL; return NULL;
cursor->portalname = NULL; cursor->portalname = NULL;
cursor->closed = false; cursor->closed = false;
@ -177,7 +198,7 @@ PLy_cursor_plan(PyObject *ob, PyObject *args)
return NULL; return NULL;
} }
if ((cursor = PyObject_New(PLyCursorObject, &PLy_CursorType)) == NULL) if ((cursor = PyObject_New(PLyCursorObject, PLy_CursorType)) == NULL)
return NULL; return NULL;
cursor->portalname = NULL; cursor->portalname = NULL;
cursor->closed = false; cursor->closed = false;
@ -272,30 +293,30 @@ PLy_cursor_plan(PyObject *ob, PyObject *args)
} }
static void static void
PLy_cursor_dealloc(PyObject *arg) PLy_cursor_dealloc(PLyCursorObject *self)
{ {
PLyCursorObject *cursor; PyTypeObject *tp = Py_TYPE(self);
Portal portal; Portal portal;
cursor = (PLyCursorObject *) arg; if (!self->closed)
if (!cursor->closed)
{ {
portal = GetPortalByName(cursor->portalname); portal = GetPortalByName(self->portalname);
if (PortalIsValid(portal)) if (PortalIsValid(portal))
{ {
UnpinPortal(portal); UnpinPortal(portal);
SPI_cursor_close(portal); SPI_cursor_close(portal);
} }
cursor->closed = true; self->closed = true;
} }
if (cursor->mcxt) if (self->mcxt)
{ {
MemoryContextDelete(cursor->mcxt); MemoryContextDelete(self->mcxt);
cursor->mcxt = NULL; self->mcxt = NULL;
} }
arg->ob_type->tp_free(arg);
PyObject_Free(self);
Py_DECREF(tp);
} }
static PyObject * static PyObject *

61
src/pl/plpython/plpy_planobject.c
View File

@ -12,7 +12,7 @@
#include "plpython.h" #include "plpython.h"
#include "utils/memutils.h" #include "utils/memutils.h"
static void PLy_plan_dealloc(PyObject *arg); static void PLy_plan_dealloc(PLyPlanObject *self);
static PyObject *PLy_plan_cursor(PyObject *self, PyObject *args); static PyObject *PLy_plan_cursor(PyObject *self, PyObject *args);
static PyObject *PLy_plan_execute(PyObject *self, PyObject *args); static PyObject *PLy_plan_execute(PyObject *self, PyObject *args);
static PyObject *PLy_plan_status(PyObject *self, PyObject *args); static PyObject *PLy_plan_status(PyObject *self, PyObject *args);
@ -26,20 +26,37 @@ static PyMethodDef PLy_plan_methods[] = {
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
static PyTypeObject PLy_PlanType = { static PyType_Slot PLyPlan_slots[] =
PyVarObject_HEAD_INIT(NULL, 0) {
.tp_name = "PLyPlan", {
.tp_basicsize = sizeof(PLyPlanObject), Py_tp_dealloc, PLy_plan_dealloc
.tp_dealloc = PLy_plan_dealloc, },
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, {
.tp_doc = PLy_plan_doc, Py_tp_doc, (char *) PLy_plan_doc
.tp_methods = PLy_plan_methods, },
{
Py_tp_methods, PLy_plan_methods
},
{
0, NULL
}
}; };
static PyType_Spec PLyPlan_spec =
{
.name = "PLyPlan",
.basicsize = sizeof(PLyPlanObject),
.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
.slots = PLyPlan_slots,
};
static PyTypeObject *PLy_PlanType;
void void
PLy_plan_init_type(void) PLy_plan_init_type(void)
{ {
if (PyType_Ready(&PLy_PlanType) < 0) PLy_PlanType = (PyTypeObject *) PyType_FromSpec(&PLyPlan_spec);
if (!PLy_PlanType)
elog(ERROR, "could not initialize PLy_PlanType"); elog(ERROR, "could not initialize PLy_PlanType");
} }
@ -48,7 +65,7 @@ PLy_plan_new(void)
{ {
PLyPlanObject *ob; PLyPlanObject *ob;
if ((ob = PyObject_New(PLyPlanObject, &PLy_PlanType)) == NULL) if ((ob = PyObject_New(PLyPlanObject, PLy_PlanType)) == NULL)
return NULL; return NULL;
ob->plan = NULL; ob->plan = NULL;
@ -63,25 +80,27 @@ PLy_plan_new(void)
bool bool
is_PLyPlanObject(PyObject *ob) is_PLyPlanObject(PyObject *ob)
{ {
return ob->ob_type == &PLy_PlanType; return ob->ob_type == PLy_PlanType;
} }
static void static void
PLy_plan_dealloc(PyObject *arg) PLy_plan_dealloc(PLyPlanObject *self)
{ {
PLyPlanObject *ob = (PLyPlanObject *) arg; PyTypeObject *tp = Py_TYPE(self);
if (ob->plan) if (self->plan)
{ {
SPI_freeplan(ob->plan); SPI_freeplan(self->plan);
ob->plan = NULL; self->plan = NULL;
} }
if (ob->mcxt) if (self->mcxt)
{ {
MemoryContextDelete(ob->mcxt); MemoryContextDelete(self->mcxt);
ob->mcxt = NULL; self->mcxt = NULL;
} }
arg->ob_type->tp_free(arg);
PyObject_Free(self);
Py_DECREF(tp);
} }

5
src/pl/plpython/plpy_procedure.c
View File

@ -350,6 +350,7 @@ PLy_procedure_compile(PLyProcedure *proc, const char *src)
{ {
PyObject *crv = NULL; PyObject *crv = NULL;
char *msrc; char *msrc;
PyObject *code0;
proc->globals = PyDict_Copy(PLy_interp_globals); proc->globals = PyDict_Copy(PLy_interp_globals);
@ -368,7 +369,9 @@ PLy_procedure_compile(PLyProcedure *proc, const char *src)
msrc = PLy_procedure_munge_source(proc->pyname, src); msrc = PLy_procedure_munge_source(proc->pyname, src);
/* Save the mangled source for later inclusion in tracebacks */ /* Save the mangled source for later inclusion in tracebacks */
proc->src = MemoryContextStrdup(proc->mcxt, msrc); proc->src = MemoryContextStrdup(proc->mcxt, msrc);
crv = PyRun_String(msrc, Py_file_input, proc->globals, NULL); code0 = Py_CompileString(msrc, "<string>", Py_file_input);
if (code0)
crv = PyEval_EvalCode(code0, proc->globals, NULL);
pfree(msrc); pfree(msrc);
if (crv != NULL) if (crv != NULL)

98
src/pl/plpython/plpy_resultobject.c
View File

@ -10,7 +10,7 @@
#include "plpy_resultobject.h" #include "plpy_resultobject.h"
#include "plpython.h" #include "plpython.h"
static void PLy_result_dealloc(PyObject *arg); static void PLy_result_dealloc(PLyResultObject *self);
static PyObject *PLy_result_colnames(PyObject *self, PyObject *unused); static PyObject *PLy_result_colnames(PyObject *self, PyObject *unused);
static PyObject *PLy_result_coltypes(PyObject *self, PyObject *unused); static PyObject *PLy_result_coltypes(PyObject *self, PyObject *unused);
static PyObject *PLy_result_coltypmods(PyObject *self, PyObject *unused); static PyObject *PLy_result_coltypmods(PyObject *self, PyObject *unused);
@ -24,17 +24,6 @@ static int PLy_result_ass_subscript(PyObject *arg, PyObject *item, PyObject *val
static char PLy_result_doc[] = "Results of a PostgreSQL query"; static char PLy_result_doc[] = "Results of a PostgreSQL query";
static PySequenceMethods PLy_result_as_sequence = {
.sq_length = PLy_result_length,
.sq_item = PLy_result_item,
};
static PyMappingMethods PLy_result_as_mapping = {
.mp_length = PLy_result_length,
.mp_subscript = PLy_result_subscript,
.mp_ass_subscript = PLy_result_ass_subscript,
};
static PyMethodDef PLy_result_methods[] = { static PyMethodDef PLy_result_methods[] = {
{"colnames", PLy_result_colnames, METH_NOARGS, NULL}, {"colnames", PLy_result_colnames, METH_NOARGS, NULL},
{"coltypes", PLy_result_coltypes, METH_NOARGS, NULL}, {"coltypes", PLy_result_coltypes, METH_NOARGS, NULL},
@ -44,23 +33,55 @@ static PyMethodDef PLy_result_methods[] = {
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
static PyTypeObject PLy_ResultType = { static PyType_Slot PLyResult_slots[] =
PyVarObject_HEAD_INIT(NULL, 0) {
.tp_name = "PLyResult", {
.tp_basicsize = sizeof(PLyResultObject), Py_tp_dealloc, PLy_result_dealloc
.tp_dealloc = PLy_result_dealloc, },
.tp_as_sequence = &PLy_result_as_sequence, {
.tp_as_mapping = &PLy_result_as_mapping, Py_sq_length, PLy_result_length
.tp_str = &PLy_result_str, },
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, {
.tp_doc = PLy_result_doc, Py_sq_item, PLy_result_item
.tp_methods = PLy_result_methods, },
{
Py_mp_length, PLy_result_length
},
{
Py_mp_subscript, PLy_result_subscript
},
{
Py_mp_ass_subscript, PLy_result_ass_subscript
},
{
Py_tp_str, PLy_result_str
},
{
Py_tp_doc, (char *) PLy_result_doc
},
{
Py_tp_methods, PLy_result_methods
},
{
0, NULL
}
}; };
static PyType_Spec PLyResult_spec =
{
.name = "PLyResult",
.basicsize = sizeof(PLyResultObject),
.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
.slots = PLyResult_slots,
};
static PyTypeObject *PLy_ResultType;
void void
PLy_result_init_type(void) PLy_result_init_type(void)
{ {
if (PyType_Ready(&PLy_ResultType) < 0) PLy_ResultType = (PyTypeObject *) PyType_FromSpec(&PLyResult_spec);
if (!PLy_ResultType)
elog(ERROR, "could not initialize PLy_ResultType"); elog(ERROR, "could not initialize PLy_ResultType");
} }
@ -69,7 +90,7 @@ PLy_result_new(void)
{ {
PLyResultObject *ob; PLyResultObject *ob;
if ((ob = PyObject_New(PLyResultObject, &PLy_ResultType)) == NULL) if ((ob = PyObject_New(PLyResultObject, PLy_ResultType)) == NULL)
return NULL; return NULL;
/* ob->tuples = NULL; */ /* ob->tuples = NULL; */
@ -89,20 +110,21 @@ PLy_result_new(void)
} }
static void static void
PLy_result_dealloc(PyObject *arg) PLy_result_dealloc(PLyResultObject *self)
{ {
PLyResultObject *ob = (PLyResultObject *) arg; PyTypeObject *tp = Py_TYPE(self);
Py_XDECREF(ob->nrows); Py_XDECREF(self->nrows);
Py_XDECREF(ob->rows); Py_XDECREF(self->rows);
Py_XDECREF(ob->status); Py_XDECREF(self->status);
if (ob->tupdesc) if (self->tupdesc)
{ {
FreeTupleDesc(ob->tupdesc); FreeTupleDesc(self->tupdesc);
ob->tupdesc = NULL; self->tupdesc = NULL;
} }
arg->ob_type->tp_free(arg); PyObject_Free(self);
Py_DECREF(tp);
} }
static PyObject * static PyObject *
@ -125,7 +147,7 @@ PLy_result_colnames(PyObject *self, PyObject *unused)
{ {
Form_pg_attribute attr = TupleDescAttr(ob->tupdesc, i); Form_pg_attribute attr = TupleDescAttr(ob->tupdesc, i);
PyList_SET_ITEM(list, i, PLyUnicode_FromString(NameStr(attr->attname))); PyList_SetItem(list, i, PLyUnicode_FromString(NameStr(attr->attname)));
} }
return list; return list;
@ -151,7 +173,7 @@ PLy_result_coltypes(PyObject *self, PyObject *unused)
{ {
Form_pg_attribute attr = TupleDescAttr(ob->tupdesc, i); Form_pg_attribute attr = TupleDescAttr(ob->tupdesc, i);
PyList_SET_ITEM(list, i, PyLong_FromLong(attr->atttypid)); PyList_SetItem(list, i, PyLong_FromLong(attr->atttypid));
} }
return list; return list;
@ -177,7 +199,7 @@ PLy_result_coltypmods(PyObject *self, PyObject *unused)
{ {
Form_pg_attribute attr = TupleDescAttr(ob->tupdesc, i); Form_pg_attribute attr = TupleDescAttr(ob->tupdesc, i);
PyList_SET_ITEM(list, i, PyLong_FromLong(attr->atttypmod)); PyList_SetItem(list, i, PyLong_FromLong(attr->atttypmod));
} }
return list; return list;
@ -227,7 +249,7 @@ PLy_result_str(PyObject *arg)
PLyResultObject *ob = (PLyResultObject *) arg; PLyResultObject *ob = (PLyResultObject *) arg;
return PyUnicode_FromFormat("<%s status=%S nrows=%S rows=%S>", return PyUnicode_FromFormat("<%s status=%S nrows=%S rows=%S>",
Py_TYPE(ob)->tp_name, "PLyResult",
ob->status, ob->status,
ob->nrows, ob->nrows,
ob->rows); ob->rows);

41
src/pl/plpython/plpy_subxactobject.c
View File

@ -15,7 +15,6 @@
List *explicit_subtransactions = NIL; List *explicit_subtransactions = NIL;
static void PLy_subtransaction_dealloc(PyObject *subxact);
static PyObject *PLy_subtransaction_enter(PyObject *self, PyObject *unused); static PyObject *PLy_subtransaction_enter(PyObject *self, PyObject *unused);
static PyObject *PLy_subtransaction_exit(PyObject *self, PyObject *args); static PyObject *PLy_subtransaction_exit(PyObject *self, PyObject *args);
@ -31,21 +30,35 @@ static PyMethodDef PLy_subtransaction_methods[] = {
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
static PyTypeObject PLy_SubtransactionType = { static PyType_Slot PLySubtransaction_slots[] =
PyVarObject_HEAD_INIT(NULL, 0) {
.tp_name = "PLySubtransaction", {
.tp_basicsize = sizeof(PLySubtransactionObject), Py_tp_doc, (char *) PLy_subtransaction_doc
.tp_dealloc = PLy_subtransaction_dealloc, },
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, {
.tp_doc = PLy_subtransaction_doc, Py_tp_methods, PLy_subtransaction_methods
.tp_methods = PLy_subtransaction_methods, },
{
0, NULL
}
}; };
static PyType_Spec PLySubtransaction_spec =
{
.name = "PLySubtransaction",
.basicsize = sizeof(PLySubtransactionObject),
.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
.slots = PLySubtransaction_slots,
};
static PyTypeObject *PLy_SubtransactionType;
void void
PLy_subtransaction_init_type(void) PLy_subtransaction_init_type(void)
{ {
if (PyType_Ready(&PLy_SubtransactionType) < 0) PLy_SubtransactionType = (PyTypeObject *) PyType_FromSpec(&PLySubtransaction_spec);
if (!PLy_SubtransactionType)
elog(ERROR, "could not initialize PLy_SubtransactionType"); elog(ERROR, "could not initialize PLy_SubtransactionType");
} }
@ -55,7 +68,7 @@ PLy_subtransaction_new(PyObject *self, PyObject *unused)
{ {
PLySubtransactionObject *ob; PLySubtransactionObject *ob;
ob = PyObject_New(PLySubtransactionObject, &PLy_SubtransactionType); ob = PyObject_New(PLySubtransactionObject, PLy_SubtransactionType);
if (ob == NULL) if (ob == NULL)
return NULL; return NULL;
@ -66,12 +79,6 @@ PLy_subtransaction_new(PyObject *self, PyObject *unused)
return (PyObject *) ob; return (PyObject *) ob;
} }
/* Python requires a dealloc function to be defined */
static void
PLy_subtransaction_dealloc(PyObject *subxact)
{
}
/* /*
* subxact.__enter__() or subxact.enter() * subxact.__enter__() or subxact.enter()
* *

6
src/pl/plpython/plpy_typeio.c
View File

@ -723,7 +723,7 @@ PLyList_FromArray_recurse(PLyDatumToOb *elm, int *dims, int ndim, int dim,
sublist = PLyList_FromArray_recurse(elm, dims, ndim, dim + 1, sublist = PLyList_FromArray_recurse(elm, dims, ndim, dim + 1,
dataptr_p, bitmap_p, bitmask_p); dataptr_p, bitmap_p, bitmask_p);
PyList_SET_ITEM(list, i, sublist); PyList_SetItem(list, i, sublist);
} }
} }
else else
@ -742,14 +742,14 @@ PLyList_FromArray_recurse(PLyDatumToOb *elm, int *dims, int ndim, int dim,
if (bitmap && (*bitmap & bitmask) == 0) if (bitmap && (*bitmap & bitmask) == 0)
{ {
Py_INCREF(Py_None); Py_INCREF(Py_None);
PyList_SET_ITEM(list, i, Py_None); PyList_SetItem(list, i, Py_None);
} }
else else
{ {
Datum itemvalue; Datum itemvalue;
itemvalue = fetch_att(dataptr, elm->typbyval, elm->typlen); itemvalue = fetch_att(dataptr, elm->typbyval, elm->typlen);
PyList_SET_ITEM(list, i, elm->func(elm, itemvalue)); PyList_SetItem(list, i, elm->func(elm, itemvalue));
dataptr = att_addlength_pointer(dataptr, elm->typlen, dataptr); dataptr = att_addlength_pointer(dataptr, elm->typlen, dataptr);
dataptr = (char *) att_align_nominal(dataptr, elm->typalign); dataptr = (char *) att_align_nominal(dataptr, elm->typalign);
} }