1 /**********************************************************************
2 * plpython.c - python as a procedural language for PostgreSQL
4 * $PostgreSQL: pgsql/src/pl/plpython/plpython.c,v 1.121 2009/06/04 18:33:08 tgl Exp $
6 *********************************************************************
9 #if defined(_MSC_VER) && defined(_DEBUG)
10 /* Python uses #pragma to bring in a non-default libpython on VC++ if
11 * _DEBUG is defined */
13 /* Also hide away errcode, since we load Python.h before postgres.h */
14 #define errcode __msvc_errcode
18 #elif defined (_MSC_VER)
19 #define errcode __msvc_errcode
27 * Py_ssize_t compat for Python <= 2.4
29 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
30 typedef int Py_ssize_t;
32 #define PY_SSIZE_T_MAX INT_MAX
33 #define PY_SSIZE_T_MIN INT_MIN
37 * PyBool_FromLong is supported from 2.3.
39 #if PY_VERSION_HEX < 0x02030000
40 #define PyBool_FromLong(x) PyInt_FromLong(x)
50 /* postgreSQL stuff */
51 #include "catalog/pg_proc.h"
52 #include "catalog/pg_type.h"
53 #include "commands/trigger.h"
54 #include "executor/spi.h"
57 #include "miscadmin.h"
58 #include "nodes/makefuncs.h"
59 #include "parser/parse_type.h"
60 #include "tcop/tcopprot.h"
61 #include "utils/builtins.h"
62 #include "utils/lsyscache.h"
63 #include "utils/memutils.h"
64 #include "utils/syscache.h"
65 #include "utils/typcache.h"
67 /* define our text domain for translations */
69 #define TEXTDOMAIN PG_TEXTDOMAIN("plpython")
76 /* convert Postgresql Datum or tuple into a PyObject.
77 * input to Python. Tuples are converted to dictionary
81 typedef PyObject *(*PLyDatumToObFunc) (const char *);
83 typedef struct PLyDatumToOb
85 PLyDatumToObFunc func;
86 FmgrInfo typfunc; /* The type's output function */
87 Oid typoid; /* The OID of the type */
92 typedef struct PLyTupleToOb
98 typedef union PLyTypeInput
104 /* convert PyObject to a Postgresql Datum or tuple.
107 typedef struct PLyObToDatum
109 FmgrInfo typfunc; /* The type's input function */
110 Oid typoid; /* The OID of the type */
115 typedef struct PLyObToTuple
121 typedef union PLyTypeOutput
127 /* all we need to move Postgresql data to Python objects,
130 typedef struct PLyTypeInfo
137 * is_rowtype can be: -1 not known yet (initial state) 0 scalar datatype
138 * 1 rowtype 2 rowtype, but I/O functions not set up yet
143 /* cached procedure data */
144 typedef struct PLyProcedure
146 char *proname; /* SQL name of procedure */
147 char *pyname; /* Python name of procedure */
148 TransactionId fn_xmin;
149 ItemPointerData fn_tid;
151 PLyTypeInfo result; /* also used to store info for trigger tuple
153 bool is_setof; /* true, if procedure returns result set */
154 PyObject *setof; /* contents of result set. */
155 char **argnames; /* Argument names */
156 PLyTypeInfo args[FUNC_MAX_ARGS];
158 PyObject *code; /* compiled procedure code */
159 PyObject *statics; /* data saved across calls, local scope */
160 PyObject *globals; /* data saved across calls, global scope */
161 PyObject *me; /* PyCObject containing pointer to this
167 typedef struct PLyPlanObject
170 void *plan; /* return of an SPI_saveplan */
177 typedef struct PLyResultObject
180 /* HeapTuple *tuples; */
181 PyObject * nrows; /* number of rows returned by query */
182 PyObject *rows; /* data rows, or None if no data returned */
183 PyObject *status; /* query status, SPI_OK_*, or SPI_ERR_* */
187 /* function declarations */
189 /* Two exported functions: first is the magic telling Postgresql
190 * what function call interface it implements. Second is for
191 * initialization of the interpreter during library load.
193 Datum plpython_call_handler(PG_FUNCTION_ARGS);
196 PG_FUNCTION_INFO_V1(plpython_call_handler);
198 /* most of the remaining of the declarations, all static */
200 /* these should only be called once at the first call
201 * of plpython_call_handler. initialize the python interpreter
204 static void PLy_init_interp(void);
205 static void PLy_init_plpy(void);
207 /* call PyErr_SetString with a vprint interface and translation support */
208 static void PLy_exception_set(PyObject *, const char *,...)
209 __attribute__((format(printf, 2, 3)));
210 /* same, with pluralized message */
211 static void PLy_exception_set_plural(PyObject *, const char *, const char *,
213 __attribute__((format(printf, 2, 5)))
214 __attribute__((format(printf, 3, 5)));
216 /* Get the innermost python procedure called from the backend */
217 static char *PLy_procedure_name(PLyProcedure *);
219 /* some utility functions */
220 static void PLy_elog(int, const char *,...)
221 __attribute__((format(printf, 2, 3)));
222 static char *PLy_traceback(int *);
224 static void *PLy_malloc(size_t);
225 static void *PLy_malloc0(size_t);
226 static char *PLy_strdup(const char *);
227 static void PLy_free(void *);
229 /* sub handlers for functions and triggers */
230 static Datum PLy_function_handler(FunctionCallInfo fcinfo, PLyProcedure *);
231 static HeapTuple PLy_trigger_handler(FunctionCallInfo fcinfo, PLyProcedure *);
233 static PyObject *PLy_function_build_args(FunctionCallInfo fcinfo, PLyProcedure *);
234 static void PLy_function_delete_args(PLyProcedure *);
235 static PyObject *PLy_trigger_build_args(FunctionCallInfo fcinfo, PLyProcedure *,
237 static HeapTuple PLy_modify_tuple(PLyProcedure *, PyObject *,
238 TriggerData *, HeapTuple);
240 static PyObject *PLy_procedure_call(PLyProcedure *, char *, PyObject *);
242 static PLyProcedure *PLy_procedure_get(FunctionCallInfo fcinfo,
245 static PLyProcedure *PLy_procedure_create(HeapTuple procTup, Oid tgreloid,
248 static void PLy_procedure_compile(PLyProcedure *, const char *);
249 static char *PLy_procedure_munge_source(const char *, const char *);
250 static void PLy_procedure_delete(PLyProcedure *);
252 static void PLy_typeinfo_init(PLyTypeInfo *);
253 static void PLy_typeinfo_dealloc(PLyTypeInfo *);
254 static void PLy_output_datum_func(PLyTypeInfo *, HeapTuple);
255 static void PLy_output_datum_func2(PLyObToDatum *, HeapTuple);
256 static void PLy_input_datum_func(PLyTypeInfo *, Oid, HeapTuple);
257 static void PLy_input_datum_func2(PLyDatumToOb *, Oid, HeapTuple);
258 static void PLy_output_tuple_funcs(PLyTypeInfo *, TupleDesc);
259 static void PLy_input_tuple_funcs(PLyTypeInfo *, TupleDesc);
261 /* conversion functions */
262 static PyObject *PLyDict_FromTuple(PLyTypeInfo *, HeapTuple, TupleDesc);
263 static PyObject *PLyBool_FromString(const char *);
264 static PyObject *PLyFloat_FromString(const char *);
265 static PyObject *PLyInt_FromString(const char *);
266 static PyObject *PLyLong_FromString(const char *);
267 static PyObject *PLyString_FromString(const char *);
269 static HeapTuple PLyMapping_ToTuple(PLyTypeInfo *, PyObject *);
270 static HeapTuple PLySequence_ToTuple(PLyTypeInfo *, PyObject *);
271 static HeapTuple PLyObject_ToTuple(PLyTypeInfo *, PyObject *);
274 * Currently active plpython function
276 static PLyProcedure *PLy_curr_procedure = NULL;
279 * When a callback from Python into PG incurs an error, we temporarily store
280 * the error information here, and return NULL to the Python interpreter.
281 * Any further callback attempts immediately fail, and when the Python
282 * interpreter returns to the calling function, we re-throw the error (even if
283 * Python thinks it trapped the error and doesn't return NULL). Eventually
284 * this ought to be improved to let Python code really truly trap the error,
285 * but that's more of a change from the pre-8.0 semantics than I have time for
286 * now --- it will only be possible if the callback query is executed inside a
289 static ErrorData *PLy_error_in_progress = NULL;
291 static PyObject *PLy_interp_globals = NULL;
292 static PyObject *PLy_interp_safe_globals = NULL;
293 static PyObject *PLy_procedure_cache = NULL;
295 /* Python exceptions */
296 static PyObject *PLy_exc_error = NULL;
297 static PyObject *PLy_exc_fatal = NULL;
298 static PyObject *PLy_exc_spi_error = NULL;
300 /* some globals for the python module */
301 static char PLy_plan_doc[] = {
302 "Store a PostgreSQL plan"
305 static char PLy_result_doc[] = {
306 "Results of a PostgreSQL query"
311 * the function definitions
315 * This routine is a crock, and so is everyplace that calls it. The problem
316 * is that the cached form of plpython functions/queries is allocated permanently
317 * (mostly via malloc()) and never released until backend exit. Subsidiary
318 * data structures such as fmgr info records therefore must live forever
319 * as well. A better implementation would store all this stuff in a per-
320 * function memory context that could be reclaimed at need. In the meantime,
321 * fmgr_info_cxt must be called specifying TopMemoryContext so that whatever
322 * it might allocate, and whatever the eventual function might allocate using
323 * fn_mcxt, will live forever too.
326 perm_fmgr_info(Oid functionId, FmgrInfo *finfo)
328 fmgr_info_cxt(functionId, finfo, TopMemoryContext);
332 plpython_call_handler(PG_FUNCTION_ARGS)
335 PLyProcedure *save_curr_proc;
336 PLyProcedure *volatile proc = NULL;
338 if (SPI_connect() != SPI_OK_CONNECT)
339 elog(ERROR, "SPI_connect failed");
341 save_curr_proc = PLy_curr_procedure;
345 if (CALLED_AS_TRIGGER(fcinfo))
347 TriggerData *tdata = (TriggerData *) fcinfo->context;
350 proc = PLy_procedure_get(fcinfo,
351 RelationGetRelid(tdata->tg_relation));
352 PLy_curr_procedure = proc;
353 trv = PLy_trigger_handler(fcinfo, proc);
354 retval = PointerGetDatum(trv);
358 proc = PLy_procedure_get(fcinfo, InvalidOid);
359 PLy_curr_procedure = proc;
360 retval = PLy_function_handler(fcinfo, proc);
365 PLy_curr_procedure = save_curr_proc;
368 /* note: Py_DECREF needs braces around it, as of 2003/08 */
376 PLy_curr_procedure = save_curr_proc;
383 /* trigger and function sub handlers
385 * the python function is expected to return Py_None if the tuple is
386 * acceptable and unmodified. Otherwise it should return a PyString
387 * object who's value is SKIP, or MODIFY. SKIP means don't perform
388 * this action. MODIFY means the tuple has been modified, so update
389 * tuple and perform action. SKIP and MODIFY assume the trigger fires
390 * BEFORE the event and is ROW level. postgres expects the function
391 * to take no arguments and return an argument of type trigger.
394 PLy_trigger_handler(FunctionCallInfo fcinfo, PLyProcedure * proc)
397 PyObject *volatile plargs = NULL;
398 PyObject *volatile plrv = NULL;
402 plargs = PLy_trigger_build_args(fcinfo, proc, &rv);
403 plrv = PLy_procedure_call(proc, "TD", plargs);
405 Assert(plrv != NULL);
406 Assert(!PLy_error_in_progress);
409 * Disconnect from SPI manager
411 if (SPI_finish() != SPI_OK_FINISH)
412 elog(ERROR, "SPI_finish failed");
415 * return of None means we're happy with the tuple
421 if (!PyString_Check(plrv))
423 (errcode(ERRCODE_DATA_EXCEPTION),
424 errmsg("unexpected return value from trigger procedure"),
425 errdetail("Expected None or a string.")));
427 srv = PyString_AsString(plrv);
428 if (pg_strcasecmp(srv, "SKIP") == 0)
430 else if (pg_strcasecmp(srv, "MODIFY") == 0)
432 TriggerData *tdata = (TriggerData *) fcinfo->context;
434 if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event) ||
435 TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
436 rv = PLy_modify_tuple(proc, plargs, tdata, rv);
439 (errmsg("PL/Python trigger function returned \"MODIFY\" in a DELETE trigger -- ignored")));
441 else if (pg_strcasecmp(srv, "OK") != 0)
444 * accept "OK" as an alternative to None; otherwise, raise an
448 (errcode(ERRCODE_DATA_EXCEPTION),
449 errmsg("unexpected return value from trigger procedure"),
450 errdetail("Expected None, \"OK\", \"SKIP\", or \"MODIFY\".")));
470 PLy_modify_tuple(PLyProcedure * proc, PyObject * pltd, TriggerData *tdata,
473 PyObject *volatile plntup;
474 PyObject *volatile plkeys;
475 PyObject *volatile platt;
476 PyObject *volatile plval;
477 PyObject *volatile plstr;
483 int *volatile modattrs;
484 Datum *volatile modvalues;
485 char *volatile modnulls;
488 plntup = plkeys = platt = plval = plstr = NULL;
495 if ((plntup = PyDict_GetItemString(pltd, "new")) == NULL)
497 (errmsg("TD[\"new\"] deleted, cannot modify row")));
498 if (!PyDict_Check(plntup))
500 (errmsg("TD[\"new\"] is not a dictionary")));
503 plkeys = PyDict_Keys(plntup);
504 natts = PyList_Size(plkeys);
506 modattrs = (int *) palloc(natts * sizeof(int));
507 modvalues = (Datum *) palloc(natts * sizeof(Datum));
508 modnulls = (char *) palloc(natts * sizeof(char));
510 tupdesc = tdata->tg_relation->rd_att;
512 for (i = 0; i < natts; i++)
516 platt = PyList_GetItem(plkeys, i);
517 if (!PyString_Check(platt))
519 (errmsg("name of TD[\"new\"] attribute at ordinal position %d is not a string", i)));
520 attn = SPI_fnumber(tupdesc, PyString_AsString(platt));
521 if (attn == SPI_ERROR_NOATTRIBUTE)
523 (errmsg("key \"%s\" found in TD[\"new\"] does not exist as a column in the triggering row",
524 PyString_AsString(platt))));
527 plval = PyDict_GetItem(plntup, platt);
529 elog(FATAL, "Python interpreter is probably corrupted");
535 if (tupdesc->attrs[atti]->attisdropped)
537 modvalues[i] = (Datum) 0;
540 else if (plval != Py_None)
542 plstr = PyObject_Str(plval);
544 PLy_elog(ERROR, "could not compute string representation of Python object in PL/Python function \"%s\" while modifying trigger row",
546 src = PyString_AsString(plstr);
549 InputFunctionCall(&proc->result.out.r.atts[atti].typfunc,
551 proc->result.out.r.atts[atti].typioparam,
552 tupdesc->attrs[atti]->atttypmod);
561 InputFunctionCall(&proc->result.out.r.atts[atti].typfunc,
563 proc->result.out.r.atts[atti].typioparam,
564 tupdesc->attrs[atti]->atttypmod);
572 rtup = SPI_modifytuple(tdata->tg_relation, otup, natts,
573 modattrs, modvalues, modnulls);
575 elog(ERROR, "SPI_modifytuple failed: error %d", SPI_result);
606 PLy_trigger_build_args(FunctionCallInfo fcinfo, PLyProcedure * proc, HeapTuple *rv)
608 TriggerData *tdata = (TriggerData *) fcinfo->context;
619 PyObject *volatile pltdata = NULL;
624 pltdata = PyDict_New();
626 PLy_elog(ERROR, "could not create new dictionary while building trigger arguments");
628 pltname = PyString_FromString(tdata->tg_trigger->tgname);
629 PyDict_SetItemString(pltdata, "name", pltname);
632 stroid = DatumGetCString(DirectFunctionCall1(oidout,
633 ObjectIdGetDatum(tdata->tg_relation->rd_id)));
634 pltrelid = PyString_FromString(stroid);
635 PyDict_SetItemString(pltdata, "relid", pltrelid);
639 stroid = SPI_getrelname(tdata->tg_relation);
640 plttablename = PyString_FromString(stroid);
641 PyDict_SetItemString(pltdata, "table_name", plttablename);
642 Py_DECREF(plttablename);
645 stroid = SPI_getnspname(tdata->tg_relation);
646 plttableschema = PyString_FromString(stroid);
647 PyDict_SetItemString(pltdata, "table_schema", plttableschema);
648 Py_DECREF(plttableschema);
652 if (TRIGGER_FIRED_BEFORE(tdata->tg_event))
653 pltwhen = PyString_FromString("BEFORE");
654 else if (TRIGGER_FIRED_AFTER(tdata->tg_event))
655 pltwhen = PyString_FromString("AFTER");
658 elog(ERROR, "unrecognized WHEN tg_event: %u", tdata->tg_event);
659 pltwhen = NULL; /* keep compiler quiet */
661 PyDict_SetItemString(pltdata, "when", pltwhen);
664 if (TRIGGER_FIRED_FOR_ROW(tdata->tg_event))
666 pltlevel = PyString_FromString("ROW");
667 PyDict_SetItemString(pltdata, "level", pltlevel);
670 if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event))
672 pltevent = PyString_FromString("INSERT");
674 PyDict_SetItemString(pltdata, "old", Py_None);
675 pytnew = PLyDict_FromTuple(&(proc->result), tdata->tg_trigtuple,
676 tdata->tg_relation->rd_att);
677 PyDict_SetItemString(pltdata, "new", pytnew);
679 *rv = tdata->tg_trigtuple;
681 else if (TRIGGER_FIRED_BY_DELETE(tdata->tg_event))
683 pltevent = PyString_FromString("DELETE");
685 PyDict_SetItemString(pltdata, "new", Py_None);
686 pytold = PLyDict_FromTuple(&(proc->result), tdata->tg_trigtuple,
687 tdata->tg_relation->rd_att);
688 PyDict_SetItemString(pltdata, "old", pytold);
690 *rv = tdata->tg_trigtuple;
692 else if (TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
694 pltevent = PyString_FromString("UPDATE");
696 pytnew = PLyDict_FromTuple(&(proc->result), tdata->tg_newtuple,
697 tdata->tg_relation->rd_att);
698 PyDict_SetItemString(pltdata, "new", pytnew);
700 pytold = PLyDict_FromTuple(&(proc->result), tdata->tg_trigtuple,
701 tdata->tg_relation->rd_att);
702 PyDict_SetItemString(pltdata, "old", pytold);
704 *rv = tdata->tg_newtuple;
708 elog(ERROR, "unrecognized OP tg_event: %u", tdata->tg_event);
709 pltevent = NULL; /* keep compiler quiet */
712 PyDict_SetItemString(pltdata, "event", pltevent);
715 else if (TRIGGER_FIRED_FOR_STATEMENT(tdata->tg_event))
717 pltlevel = PyString_FromString("STATEMENT");
718 PyDict_SetItemString(pltdata, "level", pltlevel);
721 PyDict_SetItemString(pltdata, "old", Py_None);
722 PyDict_SetItemString(pltdata, "new", Py_None);
725 if (TRIGGER_FIRED_BY_INSERT(tdata->tg_event))
726 pltevent = PyString_FromString("INSERT");
727 else if (TRIGGER_FIRED_BY_DELETE(tdata->tg_event))
728 pltevent = PyString_FromString("DELETE");
729 else if (TRIGGER_FIRED_BY_UPDATE(tdata->tg_event))
730 pltevent = PyString_FromString("UPDATE");
731 else if (TRIGGER_FIRED_BY_TRUNCATE(tdata->tg_event))
732 pltevent = PyString_FromString("TRUNCATE");
735 elog(ERROR, "unrecognized OP tg_event: %u", tdata->tg_event);
736 pltevent = NULL; /* keep compiler quiet */
739 PyDict_SetItemString(pltdata, "event", pltevent);
743 elog(ERROR, "unrecognized LEVEL tg_event: %u", tdata->tg_event);
745 if (tdata->tg_trigger->tgnargs)
753 pltargs = PyList_New(tdata->tg_trigger->tgnargs);
754 for (i = 0; i < tdata->tg_trigger->tgnargs; i++)
756 pltarg = PyString_FromString(tdata->tg_trigger->tgargs[i]);
759 * stolen, don't Py_DECREF
761 PyList_SetItem(pltargs, i, pltarg);
769 PyDict_SetItemString(pltdata, "args", pltargs);
784 /* function handler and friends */
786 PLy_function_handler(FunctionCallInfo fcinfo, PLyProcedure * proc)
789 PyObject *volatile plargs = NULL;
790 PyObject *volatile plrv = NULL;
791 PyObject *volatile plrv_so = NULL;
796 if (!proc->is_setof || proc->setof == NULL)
798 /* Simple type returning function or first time for SETOF function */
799 plargs = PLy_function_build_args(fcinfo, proc);
800 plrv = PLy_procedure_call(proc, "args", plargs);
804 * SETOF function parameters will be deleted when last row is
807 PLy_function_delete_args(proc);
808 Assert(plrv != NULL);
809 Assert(!PLy_error_in_progress);
813 * Disconnect from SPI manager and then create the return values datum
814 * (if the input function does a palloc for it this must not be
815 * allocated in the SPI memory context because SPI_finish would free
818 if (SPI_finish() != SPI_OK_FINISH)
819 elog(ERROR, "SPI_finish failed");
823 bool has_error = false;
824 ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
826 if (proc->setof == NULL)
828 /* first time -- do checks and setup */
829 if (!rsi || !IsA(rsi, ReturnSetInfo) ||
830 (rsi->allowedModes & SFRM_ValuePerCall) == 0)
833 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
834 errmsg("unsupported set function return mode"),
835 errdetail("PL/Python set-returning functions only support returning only value per call.")));
837 rsi->returnMode = SFRM_ValuePerCall;
839 /* Make iterator out of returned object */
840 proc->setof = PyObject_GetIter(plrv);
844 if (proc->setof == NULL)
846 (errcode(ERRCODE_DATATYPE_MISMATCH),
847 errmsg("returned object cannot be iterated"),
848 errdetail("PL/Python set-returning functions must return an iterable object.")));
851 /* Fetch next from iterator */
852 plrv = PyIter_Next(proc->setof);
854 rsi->isDone = ExprMultipleResult;
857 rsi->isDone = ExprEndResult;
858 has_error = PyErr_Occurred() != NULL;
861 if (rsi->isDone == ExprEndResult)
863 /* Iterator is exhausted or error happened */
864 Py_DECREF(proc->setof);
871 PLy_function_delete_args(proc);
875 (errcode(ERRCODE_DATA_EXCEPTION),
876 errmsg("error fetching next item from iterator")));
878 fcinfo->isnull = true;
884 * If the function is declared to return void, the Python return value
885 * must be None. For void-returning functions, we also treat a None
886 * return value as a special "void datum" rather than NULL (as is the
887 * case for non-void-returning functions).
889 if (proc->result.out.d.typoid == VOIDOID)
893 (errcode(ERRCODE_DATATYPE_MISMATCH),
894 errmsg("PL/Python function with return type \"void\" did not return None")));
896 fcinfo->isnull = false;
899 else if (plrv == Py_None)
901 fcinfo->isnull = true;
902 if (proc->result.is_rowtype < 1)
903 rv = InputFunctionCall(&proc->result.out.d.typfunc,
905 proc->result.out.d.typioparam,
911 else if (proc->result.is_rowtype >= 1)
913 HeapTuple tuple = NULL;
915 if (PySequence_Check(plrv))
916 /* composite type as sequence (tuple, list etc) */
917 tuple = PLySequence_ToTuple(&proc->result, plrv);
918 else if (PyMapping_Check(plrv))
919 /* composite type as mapping (currently only dict) */
920 tuple = PLyMapping_ToTuple(&proc->result, plrv);
922 /* returned as smth, must provide method __getattr__(name) */
923 tuple = PLyObject_ToTuple(&proc->result, plrv);
927 fcinfo->isnull = false;
928 rv = HeapTupleGetDatum(tuple);
932 fcinfo->isnull = true;
938 fcinfo->isnull = false;
939 plrv_so = PyObject_Str(plrv);
941 PLy_elog(ERROR, "could not create string representation of Python object in PL/Python function \"%s\" while creating return value", proc->proname);
942 plrv_sc = PyString_AsString(plrv_so);
943 rv = InputFunctionCall(&proc->result.out.d.typfunc,
945 proc->result.out.d.typioparam,
967 PLy_procedure_call(PLyProcedure * proc, char *kargs, PyObject * vargs)
971 PyDict_SetItemString(proc->globals, kargs, vargs);
972 rv = PyEval_EvalCode((PyCodeObject *) proc->code,
973 proc->globals, proc->globals);
976 * If there was an error in a PG callback, propagate that no matter what
977 * Python claims about its success.
979 if (PLy_error_in_progress)
981 ErrorData *edata = PLy_error_in_progress;
983 PLy_error_in_progress = NULL;
987 if (rv == NULL || PyErr_Occurred())
990 PLy_elog(ERROR, "PL/Python function \"%s\" failed", proc->proname);
997 PLy_function_build_args(FunctionCallInfo fcinfo, PLyProcedure * proc)
999 PyObject *volatile arg = NULL;
1000 PyObject *volatile args = NULL;
1005 args = PyList_New(proc->nargs);
1006 for (i = 0; i < proc->nargs; i++)
1008 if (proc->args[i].is_rowtype > 0)
1010 if (fcinfo->argnull[i])
1018 HeapTupleData tmptup;
1020 td = DatumGetHeapTupleHeader(fcinfo->arg[i]);
1021 /* Extract rowtype info and find a tupdesc */
1022 tupType = HeapTupleHeaderGetTypeId(td);
1023 tupTypmod = HeapTupleHeaderGetTypMod(td);
1024 tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
1026 /* Set up I/O funcs if not done yet */
1027 if (proc->args[i].is_rowtype != 1)
1028 PLy_input_tuple_funcs(&(proc->args[i]), tupdesc);
1030 /* Build a temporary HeapTuple control structure */
1031 tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
1034 arg = PLyDict_FromTuple(&(proc->args[i]), &tmptup, tupdesc);
1035 ReleaseTupleDesc(tupdesc);
1040 if (fcinfo->argnull[i])
1046 ct = OutputFunctionCall(&(proc->args[i].in.d.typfunc),
1048 arg = (proc->args[i].in.d.func) (ct);
1059 if (PyList_SetItem(args, i, arg) == -1)
1060 PLy_elog(ERROR, "PyList_SetItem() failed for PL/Python function \"%s\" while setting up arguments", proc->proname);
1062 if (proc->argnames && proc->argnames[i] &&
1063 PyDict_SetItemString(proc->globals, proc->argnames[i], arg) == -1)
1064 PLy_elog(ERROR, "PyDict_SetItemString() failed for PL/Python function \"%s\" while setting up arguments", proc->proname);
1082 PLy_function_delete_args(PLyProcedure * proc)
1086 if (!proc->argnames)
1089 for (i = 0; i < proc->nargs; i++)
1090 if (proc->argnames[i])
1091 PyDict_DelItemString(proc->globals, proc->argnames[i]);
1096 * PLyProcedure functions
1099 /* PLy_procedure_get: returns a cached PLyProcedure, or creates, stores and
1100 * returns a new PLyProcedure. fcinfo is the call info, tgreloid is the
1101 * relation OID when calling a trigger, or InvalidOid (zero) for ordinary
1104 static PLyProcedure *
1105 PLy_procedure_get(FunctionCallInfo fcinfo, Oid tgreloid)
1111 PLyProcedure *proc = NULL;
1114 fn_oid = fcinfo->flinfo->fn_oid;
1115 procTup = SearchSysCache(PROCOID,
1116 ObjectIdGetDatum(fn_oid),
1118 if (!HeapTupleIsValid(procTup))
1119 elog(ERROR, "cache lookup failed for function %u", fn_oid);
1121 rv = snprintf(key, sizeof(key), "%u_%u", fn_oid, tgreloid);
1122 if (rv >= sizeof(key) || rv < 0)
1123 elog(ERROR, "key too long");
1125 plproc = PyDict_GetItemString(PLy_procedure_cache, key);
1130 if (!PyCObject_Check(plproc))
1131 elog(FATAL, "expected a PyCObject, didn't get one");
1133 proc = PyCObject_AsVoidPtr(plproc);
1134 if (proc->me != plproc)
1135 elog(FATAL, "proc->me != plproc");
1136 /* did we find an up-to-date cache entry? */
1137 if (proc->fn_xmin != HeapTupleHeaderGetXmin(procTup->t_data) ||
1138 !ItemPointerEquals(&proc->fn_tid, &procTup->t_self))
1146 proc = PLy_procedure_create(procTup, tgreloid, key);
1148 if (OidIsValid(tgreloid))
1151 * Input/output conversion for trigger tuples. Use the result
1152 * TypeInfo variable to store the tuple conversion info. We
1153 * do this over again on each call to cover the possibility that
1154 * the relation's tupdesc changed since the trigger was last called.
1155 * PLy_input_tuple_funcs and PLy_output_tuple_funcs are responsible
1156 * for not doing repetitive work.
1158 TriggerData *tdata = (TriggerData *) fcinfo->context;
1160 Assert(CALLED_AS_TRIGGER(fcinfo));
1161 PLy_input_tuple_funcs(&(proc->result), tdata->tg_relation->rd_att);
1162 PLy_output_tuple_funcs(&(proc->result), tdata->tg_relation->rd_att);
1165 ReleaseSysCache(procTup);
1170 static PLyProcedure *
1171 PLy_procedure_create(HeapTuple procTup, Oid tgreloid, char *key)
1173 char procName[NAMEDATALEN + 256];
1174 Form_pg_proc procStruct;
1175 PLyProcedure *volatile proc;
1176 char *volatile procSource = NULL;
1182 procStruct = (Form_pg_proc) GETSTRUCT(procTup);
1184 if (OidIsValid(tgreloid))
1185 rv = snprintf(procName, sizeof(procName),
1186 "__plpython_procedure_%s_%u_trigger_%u",
1187 NameStr(procStruct->proname),
1188 HeapTupleGetOid(procTup),
1191 rv = snprintf(procName, sizeof(procName),
1192 "__plpython_procedure_%s_%u",
1193 NameStr(procStruct->proname),
1194 HeapTupleGetOid(procTup));
1195 if (rv >= sizeof(procName) || rv < 0)
1196 elog(ERROR, "procedure name would overrun buffer");
1198 proc = PLy_malloc(sizeof(PLyProcedure));
1199 proc->proname = PLy_strdup(NameStr(procStruct->proname));
1200 proc->pyname = PLy_strdup(procName);
1201 proc->fn_xmin = HeapTupleHeaderGetXmin(procTup->t_data);
1202 proc->fn_tid = procTup->t_self;
1203 /* Remember if function is STABLE/IMMUTABLE */
1205 (procStruct->provolatile != PROVOLATILE_VOLATILE);
1206 PLy_typeinfo_init(&proc->result);
1207 for (i = 0; i < FUNC_MAX_ARGS; i++)
1208 PLy_typeinfo_init(&proc->args[i]);
1210 proc->code = proc->statics = NULL;
1211 proc->globals = proc->me = NULL;
1212 proc->is_setof = procStruct->proretset;
1214 proc->argnames = NULL;
1219 * get information required for output conversion of the return value,
1220 * but only if this isn't a trigger.
1222 if (!OidIsValid(tgreloid))
1224 HeapTuple rvTypeTup;
1225 Form_pg_type rvTypeStruct;
1227 rvTypeTup = SearchSysCache(TYPEOID,
1228 ObjectIdGetDatum(procStruct->prorettype),
1230 if (!HeapTupleIsValid(rvTypeTup))
1231 elog(ERROR, "cache lookup failed for type %u",
1232 procStruct->prorettype);
1233 rvTypeStruct = (Form_pg_type) GETSTRUCT(rvTypeTup);
1235 /* Disallow pseudotype result, except for void */
1236 if (rvTypeStruct->typtype == TYPTYPE_PSEUDO &&
1237 procStruct->prorettype != VOIDOID)
1239 if (procStruct->prorettype == TRIGGEROID)
1241 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1242 errmsg("trigger functions can only be called as triggers")));
1245 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1246 errmsg("PL/Python functions cannot return type %s",
1247 format_type_be(procStruct->prorettype))));
1250 if (rvTypeStruct->typtype == TYPTYPE_COMPOSITE)
1253 * Tuple: set up later, during first call to
1254 * PLy_function_handler
1256 proc->result.out.d.typoid = procStruct->prorettype;
1257 proc->result.is_rowtype = 2;
1260 PLy_output_datum_func(&proc->result, rvTypeTup);
1262 ReleaseSysCache(rvTypeTup);
1266 * Now get information required for input conversion of the
1267 * procedure's arguments. Note that we ignore output arguments
1268 * here --- since we don't support returning record, and that was
1269 * already checked above, there's no need to worry about multiple
1272 if (procStruct->pronargs)
1281 /* extract argument type info from the pg_proc tuple */
1282 total = get_func_arg_info(procTup, &types, &names, &modes);
1284 /* count number of in+inout args into proc->nargs */
1286 proc->nargs = total;
1289 /* proc->nargs was initialized to 0 above */
1290 for (i = 0; i < total; i++)
1292 if (modes[i] != PROARGMODE_OUT &&
1293 modes[i] != PROARGMODE_TABLE)
1298 proc->argnames = (char **) PLy_malloc0(sizeof(char *) * proc->nargs);
1299 for (i = pos = 0; i < total; i++)
1301 HeapTuple argTypeTup;
1302 Form_pg_type argTypeStruct;
1305 (modes[i] == PROARGMODE_OUT ||
1306 modes[i] == PROARGMODE_TABLE))
1307 continue; /* skip OUT arguments */
1309 Assert(types[i] == procStruct->proargtypes.values[pos]);
1311 argTypeTup = SearchSysCache(TYPEOID,
1312 ObjectIdGetDatum(types[i]),
1314 if (!HeapTupleIsValid(argTypeTup))
1315 elog(ERROR, "cache lookup failed for type %u", types[i]);
1316 argTypeStruct = (Form_pg_type) GETSTRUCT(argTypeTup);
1318 /* check argument type is OK, set up I/O function info */
1319 switch (argTypeStruct->typtype)
1321 case TYPTYPE_PSEUDO:
1322 /* Disallow pseudotype argument */
1324 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1325 errmsg("PL/Python functions cannot accept type %s",
1326 format_type_be(types[i]))));
1328 case TYPTYPE_COMPOSITE:
1329 /* we'll set IO funcs at first call */
1330 proc->args[pos].is_rowtype = 2;
1333 PLy_input_datum_func(&(proc->args[pos]),
1339 /* get argument name */
1340 proc->argnames[pos] = names ? PLy_strdup(names[i]) : NULL;
1342 ReleaseSysCache(argTypeTup);
1349 * get the text of the function.
1351 prosrcdatum = SysCacheGetAttr(PROCOID, procTup,
1352 Anum_pg_proc_prosrc, &isnull);
1354 elog(ERROR, "null prosrc");
1355 procSource = TextDatumGetCString(prosrcdatum);
1357 PLy_procedure_compile(proc, procSource);
1361 proc->me = PyCObject_FromVoidPtr(proc, NULL);
1362 PyDict_SetItemString(PLy_procedure_cache, key, proc->me);
1366 PLy_procedure_delete(proc);
1378 PLy_procedure_compile(PLyProcedure * proc, const char *src)
1380 PyObject *crv = NULL;
1383 proc->globals = PyDict_Copy(PLy_interp_globals);
1386 * SD is private preserved data between calls. GD is global data shared by
1389 proc->statics = PyDict_New();
1390 PyDict_SetItemString(proc->globals, "SD", proc->statics);
1393 * insert the function code into the interpreter
1395 msrc = PLy_procedure_munge_source(proc->pyname, src);
1396 crv = PyRun_String(msrc, Py_file_input, proc->globals, NULL);
1399 if (crv != NULL && (!PyErr_Occurred()))
1402 char call[NAMEDATALEN + 256];
1407 * compile a call to the function
1409 clen = snprintf(call, sizeof(call), "%s()", proc->pyname);
1410 if (clen < 0 || clen >= sizeof(call))
1411 elog(ERROR, "string would overflow buffer");
1412 proc->code = Py_CompileString(call, "<string>", Py_eval_input);
1413 if (proc->code != NULL && (!PyErr_Occurred()))
1419 PLy_elog(ERROR, "could not compile PL/Python function \"%s\"", proc->proname);
1423 PLy_procedure_munge_source(const char *name, const char *src)
1432 * room for function source and the def statement
1434 mlen = (strlen(src) * 2) + strlen(name) + 16;
1436 mrc = PLy_malloc(mlen);
1437 plen = snprintf(mrc, mlen, "def %s():\n\t", name);
1438 Assert(plen >= 0 && plen < mlen);
1445 if (*sp == '\r' && *(sp + 1) == '\n')
1448 if (*sp == '\n' || *sp == '\r')
1461 if (mp > (mrc + mlen))
1462 elog(FATAL, "buffer overrun in PLy_munge_source");
1468 PLy_procedure_delete(PLyProcedure * proc)
1472 Py_XDECREF(proc->code);
1473 Py_XDECREF(proc->statics);
1474 Py_XDECREF(proc->globals);
1475 Py_XDECREF(proc->me);
1477 PLy_free(proc->proname);
1479 PLy_free(proc->pyname);
1480 for (i = 0; i < proc->nargs; i++)
1482 if (proc->args[i].is_rowtype == 1)
1484 if (proc->args[i].in.r.atts)
1485 PLy_free(proc->args[i].in.r.atts);
1486 if (proc->args[i].out.r.atts)
1487 PLy_free(proc->args[i].out.r.atts);
1489 if (proc->argnames && proc->argnames[i])
1490 PLy_free(proc->argnames[i]);
1493 PLy_free(proc->argnames);
1497 * Conversion functions. Remember output from Python is input to
1498 * PostgreSQL, and vice versa.
1501 PLy_input_tuple_funcs(PLyTypeInfo * arg, TupleDesc desc)
1505 if (arg->is_rowtype == 0)
1506 elog(ERROR, "PLyTypeInfo struct is initialized for a Datum");
1507 arg->is_rowtype = 1;
1509 if (arg->in.r.natts != desc->natts)
1512 PLy_free(arg->in.r.atts);
1513 arg->in.r.natts = desc->natts;
1514 arg->in.r.atts = PLy_malloc0(desc->natts * sizeof(PLyDatumToOb));
1517 for (i = 0; i < desc->natts; i++)
1521 if (desc->attrs[i]->attisdropped)
1524 if (arg->in.r.atts[i].typoid == desc->attrs[i]->atttypid)
1525 continue; /* already set up this entry */
1527 typeTup = SearchSysCache(TYPEOID,
1528 ObjectIdGetDatum(desc->attrs[i]->atttypid),
1530 if (!HeapTupleIsValid(typeTup))
1531 elog(ERROR, "cache lookup failed for type %u",
1532 desc->attrs[i]->atttypid);
1534 PLy_input_datum_func2(&(arg->in.r.atts[i]),
1535 desc->attrs[i]->atttypid,
1538 ReleaseSysCache(typeTup);
1543 PLy_output_tuple_funcs(PLyTypeInfo * arg, TupleDesc desc)
1547 if (arg->is_rowtype == 0)
1548 elog(ERROR, "PLyTypeInfo struct is initialized for a Datum");
1549 arg->is_rowtype = 1;
1551 if (arg->out.r.natts != desc->natts)
1553 if (arg->out.r.atts)
1554 PLy_free(arg->out.r.atts);
1555 arg->out.r.natts = desc->natts;
1556 arg->out.r.atts = PLy_malloc0(desc->natts * sizeof(PLyDatumToOb));
1559 for (i = 0; i < desc->natts; i++)
1563 if (desc->attrs[i]->attisdropped)
1566 if (arg->out.r.atts[i].typoid == desc->attrs[i]->atttypid)
1567 continue; /* already set up this entry */
1569 typeTup = SearchSysCache(TYPEOID,
1570 ObjectIdGetDatum(desc->attrs[i]->atttypid),
1572 if (!HeapTupleIsValid(typeTup))
1573 elog(ERROR, "cache lookup failed for type %u",
1574 desc->attrs[i]->atttypid);
1576 PLy_output_datum_func2(&(arg->out.r.atts[i]), typeTup);
1578 ReleaseSysCache(typeTup);
1583 PLy_output_datum_func(PLyTypeInfo * arg, HeapTuple typeTup)
1585 if (arg->is_rowtype > 0)
1586 elog(ERROR, "PLyTypeInfo struct is initialized for a Tuple");
1587 arg->is_rowtype = 0;
1588 PLy_output_datum_func2(&(arg->out.d), typeTup);
1592 PLy_output_datum_func2(PLyObToDatum * arg, HeapTuple typeTup)
1594 Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
1596 perm_fmgr_info(typeStruct->typinput, &arg->typfunc);
1597 arg->typoid = HeapTupleGetOid(typeTup);
1598 arg->typioparam = getTypeIOParam(typeTup);
1599 arg->typbyval = typeStruct->typbyval;
1603 PLy_input_datum_func(PLyTypeInfo * arg, Oid typeOid, HeapTuple typeTup)
1605 if (arg->is_rowtype > 0)
1606 elog(ERROR, "PLyTypeInfo struct is initialized for Tuple");
1607 arg->is_rowtype = 0;
1608 PLy_input_datum_func2(&(arg->in.d), typeOid, typeTup);
1612 PLy_input_datum_func2(PLyDatumToOb * arg, Oid typeOid, HeapTuple typeTup)
1614 Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
1616 /* Get the type's conversion information */
1617 perm_fmgr_info(typeStruct->typoutput, &arg->typfunc);
1618 arg->typoid = HeapTupleGetOid(typeTup);
1619 arg->typioparam = getTypeIOParam(typeTup);
1620 arg->typbyval = typeStruct->typbyval;
1622 /* Determine which kind of Python object we will convert to */
1626 arg->func = PLyBool_FromString;
1631 arg->func = PLyFloat_FromString;
1635 arg->func = PLyInt_FromString;
1638 arg->func = PLyLong_FromString;
1641 arg->func = PLyString_FromString;
1647 PLy_typeinfo_init(PLyTypeInfo * arg)
1649 arg->is_rowtype = -1;
1650 arg->in.r.natts = arg->out.r.natts = 0;
1651 arg->in.r.atts = NULL;
1652 arg->out.r.atts = NULL;
1656 PLy_typeinfo_dealloc(PLyTypeInfo * arg)
1658 if (arg->is_rowtype == 1)
1661 PLy_free(arg->in.r.atts);
1662 if (arg->out.r.atts)
1663 PLy_free(arg->out.r.atts);
1667 /* assumes that a bool is always returned as a 't' or 'f' */
1669 PLyBool_FromString(const char *src)
1672 * We would like to use Py_RETURN_TRUE and Py_RETURN_FALSE here for
1673 * generating SQL from trigger functions, but those are only supported in
1674 * Python >= 2.3, and we support older versions.
1675 * http://docs.python.org/api/boolObjects.html
1678 return PyBool_FromLong(1);
1679 return PyBool_FromLong(0);
1683 PLyFloat_FromString(const char *src)
1689 v = strtod(src, &eptr);
1690 if (*eptr != '\0' || errno)
1692 return PyFloat_FromDouble(v);
1696 PLyInt_FromString(const char *src)
1702 v = strtol(src, &eptr, 0);
1703 if (*eptr != '\0' || errno)
1705 return PyInt_FromLong(v);
1709 PLyLong_FromString(const char *src)
1711 return PyLong_FromString((char *) src, NULL, 0);
1715 PLyString_FromString(const char *src)
1717 return PyString_FromString(src);
1721 PLyDict_FromTuple(PLyTypeInfo * info, HeapTuple tuple, TupleDesc desc)
1723 PyObject *volatile dict;
1726 if (info->is_rowtype != 1)
1727 elog(ERROR, "PLyTypeInfo structure describes a datum");
1729 dict = PyDict_New();
1731 PLy_elog(ERROR, "could not create new dictionary");
1735 for (i = 0; i < info->in.r.natts; i++)
1743 if (desc->attrs[i]->attisdropped)
1746 key = NameStr(desc->attrs[i]->attname);
1747 vattr = heap_getattr(tuple, (i + 1), desc, &is_null);
1749 if (is_null || info->in.r.atts[i].func == NULL)
1750 PyDict_SetItemString(dict, key, Py_None);
1753 vsrc = OutputFunctionCall(&info->in.r.atts[i].typfunc,
1757 * no exceptions allowed
1759 value = info->in.r.atts[i].func(vsrc);
1761 PyDict_SetItemString(dict, key, value);
1778 PLyMapping_ToTuple(PLyTypeInfo * info, PyObject * mapping)
1786 Assert(PyMapping_Check(mapping));
1788 desc = lookup_rowtype_tupdesc(info->out.d.typoid, -1);
1789 if (info->is_rowtype == 2)
1790 PLy_output_tuple_funcs(info, desc);
1791 Assert(info->is_rowtype == 1);
1794 values = palloc(sizeof(Datum) * desc->natts);
1795 nulls = palloc(sizeof(bool) * desc->natts);
1796 for (i = 0; i < desc->natts; ++i)
1799 PyObject *volatile value,
1802 key = NameStr(desc->attrs[i]->attname);
1806 value = PyMapping_GetItemString(mapping, key);
1807 if (value == Py_None)
1809 values[i] = (Datum) NULL;
1816 so = PyObject_Str(value);
1818 PLy_elog(ERROR, "could not compute string representation of Python object");
1819 valuestr = PyString_AsString(so);
1821 values[i] = InputFunctionCall(&info->out.r.atts[i].typfunc
1823 ,info->out.r.atts[i].typioparam
1831 (errcode(ERRCODE_UNDEFINED_COLUMN),
1832 errmsg("key \"%s\" not found in mapping", key),
1833 errhint("To return null in a column, "
1834 "add the value None to the mapping with the key named after the column.")));
1848 tuple = heap_form_tuple(desc, values, nulls);
1849 ReleaseTupleDesc(desc);
1858 PLySequence_ToTuple(PLyTypeInfo * info, PyObject * sequence)
1866 Assert(PySequence_Check(sequence));
1869 * Check that sequence length is exactly same as PG tuple's. We actually
1870 * can ignore exceeding items or assume missing ones as null but to avoid
1871 * plpython developer's errors we are strict here
1873 desc = lookup_rowtype_tupdesc(info->out.d.typoid, -1);
1874 if (PySequence_Length(sequence) != desc->natts)
1876 (errcode(ERRCODE_DATATYPE_MISMATCH),
1877 errmsg("length of returned sequence did not match number of columns in row")));
1879 if (info->is_rowtype == 2)
1880 PLy_output_tuple_funcs(info, desc);
1881 Assert(info->is_rowtype == 1);
1884 values = palloc(sizeof(Datum) * desc->natts);
1885 nulls = palloc(sizeof(bool) * desc->natts);
1886 for (i = 0; i < desc->natts; ++i)
1888 PyObject *volatile value,
1894 value = PySequence_GetItem(sequence, i);
1896 if (value == Py_None)
1898 values[i] = (Datum) NULL;
1905 so = PyObject_Str(value);
1907 PLy_elog(ERROR, "could not compute string representation of Python object");
1908 valuestr = PyString_AsString(so);
1909 values[i] = InputFunctionCall(&info->out.r.atts[i].typfunc
1911 ,info->out.r.atts[i].typioparam
1930 tuple = heap_form_tuple(desc, values, nulls);
1931 ReleaseTupleDesc(desc);
1940 PLyObject_ToTuple(PLyTypeInfo * info, PyObject * object)
1948 desc = lookup_rowtype_tupdesc(info->out.d.typoid, -1);
1949 if (info->is_rowtype == 2)
1950 PLy_output_tuple_funcs(info, desc);
1951 Assert(info->is_rowtype == 1);
1954 values = palloc(sizeof(Datum) * desc->natts);
1955 nulls = palloc(sizeof(bool) * desc->natts);
1956 for (i = 0; i < desc->natts; ++i)
1959 PyObject *volatile value,
1962 key = NameStr(desc->attrs[i]->attname);
1966 value = PyObject_GetAttrString(object, key);
1967 if (value == Py_None)
1969 values[i] = (Datum) NULL;
1976 so = PyObject_Str(value);
1978 PLy_elog(ERROR, "could not compute string representation of Python object");
1979 valuestr = PyString_AsString(so);
1980 values[i] = InputFunctionCall(&info->out.r.atts[i].typfunc
1982 ,info->out.r.atts[i].typioparam
1990 (errcode(ERRCODE_UNDEFINED_COLUMN),
1991 errmsg("attribute \"%s\" does not exist in Python object", key),
1992 errhint("To return null in a column, "
1993 "let the returned object have an attribute named "
1994 "after column with value None.")));
2008 tuple = heap_form_tuple(desc, values, nulls);
2009 ReleaseTupleDesc(desc);
2017 /* initialization, some python variables function declared here */
2019 /* interface to postgresql elog */
2020 static PyObject *PLy_debug(PyObject *, PyObject *);
2021 static PyObject *PLy_log(PyObject *, PyObject *);
2022 static PyObject *PLy_info(PyObject *, PyObject *);
2023 static PyObject *PLy_notice(PyObject *, PyObject *);
2024 static PyObject *PLy_warning(PyObject *, PyObject *);
2025 static PyObject *PLy_error(PyObject *, PyObject *);
2026 static PyObject *PLy_fatal(PyObject *, PyObject *);
2028 /* PLyPlanObject, PLyResultObject and SPI interface */
2029 #define is_PLyPlanObject(x) ((x)->ob_type == &PLy_PlanType)
2030 static PyObject *PLy_plan_new(void);
2031 static void PLy_plan_dealloc(PyObject *);
2032 static PyObject *PLy_plan_getattr(PyObject *, char *);
2033 static PyObject *PLy_plan_status(PyObject *, PyObject *);
2035 static PyObject *PLy_result_new(void);
2036 static void PLy_result_dealloc(PyObject *);
2037 static PyObject *PLy_result_getattr(PyObject *, char *);
2038 static PyObject *PLy_result_nrows(PyObject *, PyObject *);
2039 static PyObject *PLy_result_status(PyObject *, PyObject *);
2040 static Py_ssize_t PLy_result_length(PyObject *);
2041 static PyObject *PLy_result_item(PyObject *, Py_ssize_t);
2042 static PyObject *PLy_result_slice(PyObject *, Py_ssize_t, Py_ssize_t);
2043 static int PLy_result_ass_item(PyObject *, Py_ssize_t, PyObject *);
2044 static int PLy_result_ass_slice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
2047 static PyObject *PLy_spi_prepare(PyObject *, PyObject *);
2048 static PyObject *PLy_spi_execute(PyObject *, PyObject *);
2049 static PyObject *PLy_spi_execute_query(char *query, long limit);
2050 static PyObject *PLy_spi_execute_plan(PyObject *, PyObject *, long);
2051 static PyObject *PLy_spi_execute_fetch_result(SPITupleTable *, int, int);
2054 static PyTypeObject PLy_PlanType = {
2055 PyObject_HEAD_INIT(NULL)
2057 "PLyPlan", /* tp_name */
2058 sizeof(PLyPlanObject), /* tp_size */
2059 0, /* tp_itemsize */
2064 PLy_plan_dealloc, /* tp_dealloc */
2066 PLy_plan_getattr, /* tp_getattr */
2070 0, /* tp_as_number */
2071 0, /* tp_as_sequence */
2072 0, /* tp_as_mapping */
2076 0, /* tp_getattro */
2077 0, /* tp_setattro */
2078 0, /* tp_as_buffer */
2079 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
2080 PLy_plan_doc, /* tp_doc */
2083 static PyMethodDef PLy_plan_methods[] = {
2084 {"status", PLy_plan_status, METH_VARARGS, NULL},
2085 {NULL, NULL, 0, NULL}
2088 static PySequenceMethods PLy_result_as_sequence = {
2089 PLy_result_length, /* sq_length */
2090 NULL, /* sq_concat */
2091 NULL, /* sq_repeat */
2092 PLy_result_item, /* sq_item */
2093 PLy_result_slice, /* sq_slice */
2094 PLy_result_ass_item, /* sq_ass_item */
2095 PLy_result_ass_slice, /* sq_ass_slice */
2098 static PyTypeObject PLy_ResultType = {
2099 PyObject_HEAD_INIT(NULL)
2101 "PLyResult", /* tp_name */
2102 sizeof(PLyResultObject), /* tp_size */
2103 0, /* tp_itemsize */
2108 PLy_result_dealloc, /* tp_dealloc */
2110 PLy_result_getattr, /* tp_getattr */
2114 0, /* tp_as_number */
2115 &PLy_result_as_sequence, /* tp_as_sequence */
2116 0, /* tp_as_mapping */
2120 0, /* tp_getattro */
2121 0, /* tp_setattro */
2122 0, /* tp_as_buffer */
2123 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
2124 PLy_result_doc, /* tp_doc */
2127 static PyMethodDef PLy_result_methods[] = {
2128 {"nrows", PLy_result_nrows, METH_VARARGS, NULL},
2129 {"status", PLy_result_status, METH_VARARGS, NULL},
2130 {NULL, NULL, 0, NULL}
2133 static PyMethodDef PLy_methods[] = {
2137 {"debug", PLy_debug, METH_VARARGS, NULL},
2138 {"log", PLy_log, METH_VARARGS, NULL},
2139 {"info", PLy_info, METH_VARARGS, NULL},
2140 {"notice", PLy_notice, METH_VARARGS, NULL},
2141 {"warning", PLy_warning, METH_VARARGS, NULL},
2142 {"error", PLy_error, METH_VARARGS, NULL},
2143 {"fatal", PLy_fatal, METH_VARARGS, NULL},
2146 * create a stored plan
2148 {"prepare", PLy_spi_prepare, METH_VARARGS, NULL},
2151 * execute a plan or query
2153 {"execute", PLy_spi_execute, METH_VARARGS, NULL},
2155 {NULL, NULL, 0, NULL}
2159 /* plan object methods */
2165 if ((ob = PyObject_NEW(PLyPlanObject, &PLy_PlanType)) == NULL)
2173 return (PyObject *) ob;
2178 PLy_plan_dealloc(PyObject * arg)
2180 PLyPlanObject *ob = (PLyPlanObject *) arg;
2183 SPI_freeplan(ob->plan);
2185 PLy_free(ob->types);
2190 for (i = 0; i < ob->nargs; i++)
2191 PLy_typeinfo_dealloc(&ob->args[i]);
2195 arg->ob_type->tp_free(arg);
2200 PLy_plan_getattr(PyObject * self, char *name)
2202 return Py_FindMethod(PLy_plan_methods, self, name);
2206 PLy_plan_status(PyObject * self, PyObject * args)
2208 if (PyArg_ParseTuple(args, ""))
2212 /* return PyInt_FromLong(self->status); */
2214 PLy_exception_set(PLy_exc_error, "plan.status takes no arguments");
2220 /* result object methods */
2223 PLy_result_new(void)
2225 PLyResultObject *ob;
2227 if ((ob = PyObject_NEW(PLyResultObject, &PLy_ResultType)) == NULL)
2230 /* ob->tuples = NULL; */
2233 ob->status = Py_None;
2234 ob->nrows = PyInt_FromLong(-1);
2235 ob->rows = PyList_New(0);
2237 return (PyObject *) ob;
2241 PLy_result_dealloc(PyObject * arg)
2243 PLyResultObject *ob = (PLyResultObject *) arg;
2245 Py_XDECREF(ob->nrows);
2246 Py_XDECREF(ob->rows);
2247 Py_XDECREF(ob->status);
2249 arg->ob_type->tp_free(arg);
2253 PLy_result_getattr(PyObject * self, char *name)
2255 return Py_FindMethod(PLy_result_methods, self, name);
2259 PLy_result_nrows(PyObject * self, PyObject * args)
2261 PLyResultObject *ob = (PLyResultObject *) self;
2263 Py_INCREF(ob->nrows);
2268 PLy_result_status(PyObject * self, PyObject * args)
2270 PLyResultObject *ob = (PLyResultObject *) self;
2272 Py_INCREF(ob->status);
2277 PLy_result_length(PyObject * arg)
2279 PLyResultObject *ob = (PLyResultObject *) arg;
2281 return PyList_Size(ob->rows);
2285 PLy_result_item(PyObject * arg, Py_ssize_t idx)
2288 PLyResultObject *ob = (PLyResultObject *) arg;
2290 rv = PyList_GetItem(ob->rows, idx);
2297 PLy_result_ass_item(PyObject * arg, Py_ssize_t idx, PyObject * item)
2300 PLyResultObject *ob = (PLyResultObject *) arg;
2303 rv = PyList_SetItem(ob->rows, idx, item);
2308 PLy_result_slice(PyObject * arg, Py_ssize_t lidx, Py_ssize_t hidx)
2311 PLyResultObject *ob = (PLyResultObject *) arg;
2313 rv = PyList_GetSlice(ob->rows, lidx, hidx);
2321 PLy_result_ass_slice(PyObject * arg, Py_ssize_t lidx, Py_ssize_t hidx, PyObject * slice)
2324 PLyResultObject *ob = (PLyResultObject *) arg;
2326 rv = PyList_SetSlice(ob->rows, lidx, hidx, slice);
2332 PLy_spi_prepare(PyObject * self, PyObject * args)
2334 PLyPlanObject *plan;
2335 PyObject *list = NULL;
2336 PyObject *volatile optr = NULL;
2339 MemoryContext oldcontext;
2341 /* Can't execute more if we have an unhandled error */
2342 if (PLy_error_in_progress)
2344 PLy_exception_set(PLy_exc_error, "transaction aborted");
2348 if (!PyArg_ParseTuple(args, "s|O", &query, &list))
2350 PLy_exception_set(PLy_exc_spi_error,
2351 "invalid arguments for plpy.prepare");
2355 if (list && (!PySequence_Check(list)))
2357 PLy_exception_set(PLy_exc_spi_error,
2358 "second argument of plpy.prepare must be a sequence");
2362 if ((plan = (PLyPlanObject *) PLy_plan_new()) == NULL)
2365 oldcontext = CurrentMemoryContext;
2373 nargs = PySequence_Length(list);
2376 plan->nargs = nargs;
2377 plan->types = PLy_malloc(sizeof(Oid) * nargs);
2378 plan->values = PLy_malloc(sizeof(Datum) * nargs);
2379 plan->args = PLy_malloc(sizeof(PLyTypeInfo) * nargs);
2382 * the other loop might throw an exception, if PLyTypeInfo
2383 * member isn't properly initialized the Py_DECREF(plan) will
2386 for (i = 0; i < nargs; i++)
2388 PLy_typeinfo_init(&plan->args[i]);
2389 plan->values[i] = PointerGetDatum(NULL);
2392 for (i = 0; i < nargs; i++)
2398 Form_pg_type typeStruct;
2400 optr = PySequence_GetItem(list, i);
2401 if (!PyString_Check(optr))
2403 (errmsg("plpy.prepare: type name at ordinal position %d is not a string", i)));
2404 sptr = PyString_AsString(optr);
2406 /********************************************************
2407 * Resolve argument type names and then look them up by
2408 * oid in the system cache, and remember the required
2409 *information for input conversion.
2410 ********************************************************/
2412 parseTypeString(sptr, &typeId, &typmod);
2414 typeTup = SearchSysCache(TYPEOID,
2415 ObjectIdGetDatum(typeId),
2417 if (!HeapTupleIsValid(typeTup))
2418 elog(ERROR, "cache lookup failed for type %u", typeId);
2421 optr = NULL; /* this is important */
2423 plan->types[i] = typeId;
2424 typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
2425 if (typeStruct->typtype != TYPTYPE_COMPOSITE)
2426 PLy_output_datum_func(&plan->args[i], typeTup);
2429 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2430 errmsg("plpy.prepare does not support composite types")));
2431 ReleaseSysCache(typeTup);
2436 plan->plan = SPI_prepare(query, plan->nargs, plan->types);
2437 if (plan->plan == NULL)
2438 elog(ERROR, "SPI_prepare failed: %s",
2439 SPI_result_code_string(SPI_result));
2441 /* transfer plan from procCxt to topCxt */
2442 tmpplan = plan->plan;
2443 plan->plan = SPI_saveplan(tmpplan);
2444 SPI_freeplan(tmpplan);
2445 if (plan->plan == NULL)
2446 elog(ERROR, "SPI_saveplan failed: %s",
2447 SPI_result_code_string(SPI_result));
2451 MemoryContextSwitchTo(oldcontext);
2452 PLy_error_in_progress = CopyErrorData();
2456 if (!PyErr_Occurred())
2457 PLy_exception_set(PLy_exc_spi_error,
2458 "unrecognized error in PLy_spi_prepare");
2459 /* XXX this oughta be replaced with errcontext mechanism */
2460 PLy_elog(WARNING, "in PL/Python function \"%s\"",
2461 PLy_procedure_name(PLy_curr_procedure));
2466 return (PyObject *) plan;
2469 /* execute(query="select * from foo", limit=5)
2470 * execute(plan=plan, values=(foo, bar), limit=5)
2473 PLy_spi_execute(PyObject * self, PyObject * args)
2477 PyObject *list = NULL;
2480 /* Can't execute more if we have an unhandled error */
2481 if (PLy_error_in_progress)
2483 PLy_exception_set(PLy_exc_error, "transaction aborted");
2487 if (PyArg_ParseTuple(args, "s|l", &query, &limit))
2488 return PLy_spi_execute_query(query, limit);
2492 if (PyArg_ParseTuple(args, "O|Ol", &plan, &list, &limit) &&
2493 is_PLyPlanObject(plan))
2494 return PLy_spi_execute_plan(plan, list, limit);
2496 PLy_exception_set(PLy_exc_error, "plpy.execute expected a query or a plan");
2501 PLy_spi_execute_plan(PyObject * ob, PyObject * list, long limit)
2506 PLyPlanObject *plan;
2507 MemoryContext oldcontext;
2511 if (!PySequence_Check(list) || PyString_Check(list))
2513 PLy_exception_set(PLy_exc_spi_error, "plpy.execute takes a sequence as its second argument");
2516 nargs = PySequence_Length(list);
2521 plan = (PLyPlanObject *) ob;
2523 if (nargs != plan->nargs)
2526 PyObject *so = PyObject_Str(list);
2529 PLy_elog(ERROR, "PL/Python function \"%s\" could not execute plan",
2530 PLy_procedure_name(PLy_curr_procedure));
2531 sv = PyString_AsString(so);
2532 PLy_exception_set_plural(PLy_exc_spi_error,
2533 "Expected sequence of %d argument, got %d: %s",
2534 "Expected sequence of %d arguments, got %d: %s",
2536 plan->nargs, nargs, sv);
2542 oldcontext = CurrentMemoryContext;
2545 char *nulls = palloc(nargs * sizeof(char));
2548 for (j = 0; j < nargs; j++)
2553 elem = PySequence_GetItem(list, j);
2554 if (elem != Py_None)
2556 so = PyObject_Str(elem);
2558 PLy_elog(ERROR, "PL/Python function \"%s\" could not execute plan",
2559 PLy_procedure_name(PLy_curr_procedure));
2564 char *sv = PyString_AsString(so);
2567 InputFunctionCall(&(plan->args[j].out.d.typfunc),
2569 plan->args[j].out.d.typioparam,
2586 InputFunctionCall(&(plan->args[j].out.d.typfunc),
2588 plan->args[j].out.d.typioparam,
2594 rv = SPI_execute_plan(plan->plan, plan->values, nulls,
2595 PLy_curr_procedure->fn_readonly, limit);
2603 MemoryContextSwitchTo(oldcontext);
2604 PLy_error_in_progress = CopyErrorData();
2608 * cleanup plan->values array
2610 for (k = 0; k < nargs; k++)
2612 if (!plan->args[k].out.d.typbyval &&
2613 (plan->values[k] != PointerGetDatum(NULL)))
2615 pfree(DatumGetPointer(plan->values[k]));
2616 plan->values[k] = PointerGetDatum(NULL);
2620 if (!PyErr_Occurred())
2621 PLy_exception_set(PLy_exc_error,
2622 "unrecognized error in PLy_spi_execute_plan");
2623 /* XXX this oughta be replaced with errcontext mechanism */
2624 PLy_elog(WARNING, "in PL/Python function \"%s\"",
2625 PLy_procedure_name(PLy_curr_procedure));
2630 for (i = 0; i < nargs; i++)
2632 if (!plan->args[i].out.d.typbyval &&
2633 (plan->values[i] != PointerGetDatum(NULL)))
2635 pfree(DatumGetPointer(plan->values[i]));
2636 plan->values[i] = PointerGetDatum(NULL);
2642 PLy_exception_set(PLy_exc_spi_error,
2643 "SPI_execute_plan failed: %s",
2644 SPI_result_code_string(rv));
2648 return PLy_spi_execute_fetch_result(SPI_tuptable, SPI_processed, rv);
2652 PLy_spi_execute_query(char *query, long limit)
2655 MemoryContext oldcontext;
2657 oldcontext = CurrentMemoryContext;
2660 rv = SPI_execute(query, PLy_curr_procedure->fn_readonly, limit);
2664 MemoryContextSwitchTo(oldcontext);
2665 PLy_error_in_progress = CopyErrorData();
2667 if (!PyErr_Occurred())
2668 PLy_exception_set(PLy_exc_spi_error,
2669 "unrecognized error in PLy_spi_execute_query");
2670 /* XXX this oughta be replaced with errcontext mechanism */
2671 PLy_elog(WARNING, "in PL/Python function \"%s\"",
2672 PLy_procedure_name(PLy_curr_procedure));
2679 PLy_exception_set(PLy_exc_spi_error,
2680 "SPI_execute failed: %s",
2681 SPI_result_code_string(rv));
2685 return PLy_spi_execute_fetch_result(SPI_tuptable, SPI_processed, rv);
2689 PLy_spi_execute_fetch_result(SPITupleTable *tuptable, int rows, int status)
2691 PLyResultObject *result;
2692 MemoryContext oldcontext;
2694 result = (PLyResultObject *) PLy_result_new();
2695 Py_DECREF(result->status);
2696 result->status = PyInt_FromLong(status);
2698 if (status > 0 && tuptable == NULL)
2700 Py_DECREF(result->nrows);
2701 result->nrows = PyInt_FromLong(rows);
2703 else if (status > 0 && tuptable != NULL)
2708 Py_DECREF(result->nrows);
2709 result->nrows = PyInt_FromLong(rows);
2710 PLy_typeinfo_init(&args);
2712 oldcontext = CurrentMemoryContext;
2717 Py_DECREF(result->rows);
2718 result->rows = PyList_New(rows);
2720 PLy_input_tuple_funcs(&args, tuptable->tupdesc);
2721 for (i = 0; i < rows; i++)
2723 PyObject *row = PLyDict_FromTuple(&args, tuptable->vals[i],
2726 PyList_SetItem(result->rows, i, row);
2728 PLy_typeinfo_dealloc(&args);
2730 SPI_freetuptable(tuptable);
2735 MemoryContextSwitchTo(oldcontext);
2736 PLy_error_in_progress = CopyErrorData();
2738 if (!PyErr_Occurred())
2739 PLy_exception_set(PLy_exc_error,
2740 "unrecognized error in PLy_spi_execute_fetch_result");
2742 PLy_typeinfo_dealloc(&args);
2748 return (PyObject *) result;
2753 * language handler and interpreter initialization
2757 * _PG_init() - library load-time initialization
2759 * DO NOT make this static nor change its name!
2764 /* Be sure we do initialization only once (should be redundant now) */
2765 static bool inited = false;
2770 pg_bindtextdomain(TEXTDOMAIN);
2775 if (PyErr_Occurred())
2776 PLy_elog(FATAL, "untrapped error in initialization");
2777 PLy_procedure_cache = PyDict_New();
2778 if (PLy_procedure_cache == NULL)
2779 PLy_elog(ERROR, "could not create procedure cache");
2785 PLy_init_interp(void)
2789 mainmod = PyImport_AddModule("__main__");
2790 if (mainmod == NULL || PyErr_Occurred())
2791 PLy_elog(ERROR, "could not import \"__main__\" module");
2793 PLy_interp_globals = PyModule_GetDict(mainmod);
2794 PLy_interp_safe_globals = PyDict_New();
2795 PyDict_SetItemString(PLy_interp_globals, "GD", PLy_interp_safe_globals);
2797 if (PLy_interp_globals == NULL || PyErr_Occurred())
2798 PLy_elog(ERROR, "could not initialize globals");
2811 * initialize plpy module
2813 if (PyType_Ready(&PLy_PlanType) < 0)
2814 elog(ERROR, "could not initialize PLy_PlanType");
2815 if (PyType_Ready(&PLy_ResultType) < 0)
2816 elog(ERROR, "could not initialize PLy_ResultType");
2818 plpy = Py_InitModule("plpy", PLy_methods);
2819 plpy_dict = PyModule_GetDict(plpy);
2821 /* PyDict_SetItemString(plpy, "PlanType", (PyObject *) &PLy_PlanType); */
2823 PLy_exc_error = PyErr_NewException("plpy.Error", NULL, NULL);
2824 PLy_exc_fatal = PyErr_NewException("plpy.Fatal", NULL, NULL);
2825 PLy_exc_spi_error = PyErr_NewException("plpy.SPIError", NULL, NULL);
2826 PyDict_SetItemString(plpy_dict, "Error", PLy_exc_error);
2827 PyDict_SetItemString(plpy_dict, "Fatal", PLy_exc_fatal);
2828 PyDict_SetItemString(plpy_dict, "SPIError", PLy_exc_spi_error);
2831 * initialize main module, and add plpy
2833 main_mod = PyImport_AddModule("__main__");
2834 main_dict = PyModule_GetDict(main_mod);
2835 plpy_mod = PyImport_AddModule("plpy");
2836 PyDict_SetItemString(main_dict, "plpy", plpy_mod);
2837 if (PyErr_Occurred())
2838 elog(ERROR, "could not initialize plpy");
2841 /* the python interface to the elog function
2842 * don't confuse these with PLy_elog
2844 static PyObject *PLy_output(volatile int, PyObject *, PyObject *);
2847 PLy_debug(PyObject * self, PyObject * args)
2849 return PLy_output(DEBUG2, self, args);
2853 PLy_log(PyObject * self, PyObject * args)
2855 return PLy_output(LOG, self, args);
2859 PLy_info(PyObject * self, PyObject * args)
2861 return PLy_output(INFO, self, args);
2865 PLy_notice(PyObject * self, PyObject * args)
2867 return PLy_output(NOTICE, self, args);
2871 PLy_warning(PyObject * self, PyObject * args)
2873 return PLy_output(WARNING, self, args);
2877 PLy_error(PyObject * self, PyObject * args)
2879 return PLy_output(ERROR, self, args);
2883 PLy_fatal(PyObject * self, PyObject * args)
2885 return PLy_output(FATAL, self, args);
2890 PLy_output(volatile int level, PyObject * self, PyObject * args)
2894 MemoryContext oldcontext;
2896 so = PyObject_Str(args);
2897 if (so == NULL || ((sv = PyString_AsString(so)) == NULL))
2900 sv = dgettext(TEXTDOMAIN, "could not parse error message in plpy.elog");
2903 oldcontext = CurrentMemoryContext;
2906 elog(level, "%s", sv);
2910 MemoryContextSwitchTo(oldcontext);
2911 PLy_error_in_progress = CopyErrorData();
2916 * returning NULL here causes the python interpreter to bail. when
2917 * control passes back to PLy_procedure_call, we check for PG
2918 * exceptions and re-throw the error.
2920 PyErr_SetString(PLy_exc_error, sv);
2928 * return a legal object so the interpreter will continue on its merry way
2936 * Get the name of the last procedure called by the backend (the
2937 * innermost, if a plpython procedure call calls the backend and the
2938 * backend calls another plpython procedure).
2940 * NB: this returns the SQL name, not the internal Python procedure name
2943 PLy_procedure_name(PLyProcedure * proc)
2946 return "<unknown procedure>";
2947 return proc->proname;
2951 * Call PyErr_SetString with a vprint interface and translation support
2954 PLy_exception_set(PyObject * exc, const char *fmt,...)
2960 vsnprintf(buf, sizeof(buf), dgettext(TEXTDOMAIN, fmt), ap);
2963 PyErr_SetString(exc, buf);
2967 * The same, pluralized.
2970 PLy_exception_set_plural(PyObject *exc,
2971 const char *fmt_singular, const char *fmt_plural,
2972 unsigned long n,...)
2978 vsnprintf(buf, sizeof(buf),
2979 dngettext(TEXTDOMAIN, fmt_singular, fmt_plural, n),
2983 PyErr_SetString(exc, buf);
2986 /* Emit a PG error or notice, together with any available info about the
2987 * current Python error. This should be used to propagate Python errors
2991 PLy_elog(int elevel, const char *fmt,...)
2995 StringInfoData emsg;
2997 xmsg = PLy_traceback(&xlevel);
2999 initStringInfo(&emsg);
3006 success = appendStringInfoVA(&emsg, dgettext(TEXTDOMAIN, fmt), ap);
3010 enlargeStringInfo(&emsg, emsg.maxlen);
3016 (errmsg("PL/Python: %s", emsg.data),
3017 (xmsg) ? errdetail("%s", xmsg) : 0));
3034 PLy_traceback(int *xlevel)
3043 StringInfoData xstr;
3046 * get the current exception
3048 PyErr_Fetch(&e, &v, &tb);
3051 * oops, no exception, return
3059 PyErr_NormalizeException(&e, &v, &tb);
3062 eob = PyObject_Str(e);
3063 if (v && ((vob = PyObject_Str(v)) != NULL))
3064 vstr = PyString_AsString(vob);
3069 * I'm not sure what to do if eob is NULL here -- we can't call PLy_elog
3070 * because that function calls us, so we could end up with infinite
3071 * recursion. I'm not even sure if eob could be NULL here -- would an
3072 * Assert() be more appropriate?
3074 estr = eob ? PyString_AsString(eob) : "unrecognized exception";
3075 initStringInfo(&xstr);
3076 appendStringInfo(&xstr, "%s: %s", estr, vstr);
3083 * intuit an appropriate error level based on the exception type
3085 if (PLy_exc_error && PyErr_GivenExceptionMatches(e, PLy_exc_error))
3087 else if (PLy_exc_fatal && PyErr_GivenExceptionMatches(e, PLy_exc_fatal))
3096 /* python module code */
3098 /* some dumb utility functions */
3100 PLy_malloc(size_t bytes)
3102 void *ptr = malloc(bytes);
3106 (errcode(ERRCODE_OUT_OF_MEMORY),
3107 errmsg("out of memory")));
3112 PLy_malloc0(size_t bytes)
3114 void *ptr = PLy_malloc(bytes);
3116 MemSet(ptr, 0, bytes);
3121 PLy_strdup(const char *str)
3126 len = strlen(str) + 1;
3127 result = PLy_malloc(len);
3128 memcpy(result, str, len);
3133 /* define this away */