Branch data Line data Source code
1 : : /*
2 : : * the plpy module
3 : : *
4 : : * src/pl/plpython/plpy_plpymodule.c
5 : : */
6 : :
7 : : #include "postgres.h"
8 : :
9 : : #include "mb/pg_wchar.h"
10 : : #include "plpy_cursorobject.h"
11 : : #include "plpy_elog.h"
12 : : #include "plpy_planobject.h"
13 : : #include "plpy_plpymodule.h"
14 : : #include "plpy_resultobject.h"
15 : : #include "plpy_spi.h"
16 : : #include "plpy_subxactobject.h"
17 : : #include "plpy_util.h"
18 : : #include "utils/builtins.h"
19 : :
20 : : HTAB *PLy_spi_exceptions = NULL;
21 : :
22 : :
23 : : static void PLy_add_exceptions(PyObject *plpy);
24 : : static PyObject *PLy_create_exception(char *name,
25 : : PyObject *base, PyObject *dict,
26 : : const char *modname, PyObject *mod);
27 : : static void PLy_generate_spi_exceptions(PyObject *mod, PyObject *base);
28 : :
29 : : /* module functions */
30 : : static PyObject *PLy_debug(PyObject *self, PyObject *args, PyObject *kw);
31 : : static PyObject *PLy_log(PyObject *self, PyObject *args, PyObject *kw);
32 : : static PyObject *PLy_info(PyObject *self, PyObject *args, PyObject *kw);
33 : : static PyObject *PLy_notice(PyObject *self, PyObject *args, PyObject *kw);
34 : : static PyObject *PLy_warning(PyObject *self, PyObject *args, PyObject *kw);
35 : : static PyObject *PLy_error(PyObject *self, PyObject *args, PyObject *kw);
36 : : static PyObject *PLy_fatal(PyObject *self, PyObject *args, PyObject *kw);
37 : : static PyObject *PLy_quote_literal(PyObject *self, PyObject *args);
38 : : static PyObject *PLy_quote_nullable(PyObject *self, PyObject *args);
39 : : static PyObject *PLy_quote_ident(PyObject *self, PyObject *args);
40 : :
41 : :
42 : : /* A list of all known exceptions, generated from backend/utils/errcodes.txt */
43 : : typedef struct ExceptionMap
44 : : {
45 : : char *name;
46 : : char *classname;
47 : : int sqlstate;
48 : : } ExceptionMap;
49 : :
50 : : static const ExceptionMap exception_map[] = {
51 : : #include "spiexceptions.h"
52 : : {NULL, NULL, 0}
53 : : };
54 : :
55 : : static PyMethodDef PLy_methods[] = {
56 : : /*
57 : : * logging methods
58 : : */
59 : : {"debug", (PyCFunction) (pg_funcptr_t) PLy_debug, METH_VARARGS | METH_KEYWORDS, NULL},
60 : : {"log", (PyCFunction) (pg_funcptr_t) PLy_log, METH_VARARGS | METH_KEYWORDS, NULL},
61 : : {"info", (PyCFunction) (pg_funcptr_t) PLy_info, METH_VARARGS | METH_KEYWORDS, NULL},
62 : : {"notice", (PyCFunction) (pg_funcptr_t) PLy_notice, METH_VARARGS | METH_KEYWORDS, NULL},
63 : : {"warning", (PyCFunction) (pg_funcptr_t) PLy_warning, METH_VARARGS | METH_KEYWORDS, NULL},
64 : : {"error", (PyCFunction) (pg_funcptr_t) PLy_error, METH_VARARGS | METH_KEYWORDS, NULL},
65 : : {"fatal", (PyCFunction) (pg_funcptr_t) PLy_fatal, METH_VARARGS | METH_KEYWORDS, NULL},
66 : :
67 : : /*
68 : : * create a stored plan
69 : : */
70 : : {"prepare", PLy_spi_prepare, METH_VARARGS, NULL},
71 : :
72 : : /*
73 : : * execute a plan or query
74 : : */
75 : : {"execute", PLy_spi_execute, METH_VARARGS, NULL},
76 : :
77 : : /*
78 : : * escaping strings
79 : : */
80 : : {"quote_literal", PLy_quote_literal, METH_VARARGS, NULL},
81 : : {"quote_nullable", PLy_quote_nullable, METH_VARARGS, NULL},
82 : : {"quote_ident", PLy_quote_ident, METH_VARARGS, NULL},
83 : :
84 : : /*
85 : : * create the subtransaction context manager
86 : : */
87 : : {"subtransaction", PLy_subtransaction_new, METH_NOARGS, NULL},
88 : :
89 : : /*
90 : : * create a cursor
91 : : */
92 : : {"cursor", PLy_cursor, METH_VARARGS, NULL},
93 : :
94 : : /*
95 : : * transaction control
96 : : */
97 : : {"commit", PLy_commit, METH_NOARGS, NULL},
98 : : {"rollback", PLy_rollback, METH_NOARGS, NULL},
99 : :
100 : : {NULL, NULL, 0, NULL}
101 : : };
102 : :
103 : : static PyMethodDef PLy_exc_methods[] = {
104 : : {NULL, NULL, 0, NULL}
105 : : };
106 : :
107 : : static PyModuleDef PLy_module = {
108 : : PyModuleDef_HEAD_INIT,
109 : : .m_name = "plpy",
110 : : .m_size = -1,
111 : : .m_methods = PLy_methods,
112 : : };
113 : :
114 : : static PyModuleDef PLy_exc_module = {
115 : : PyModuleDef_HEAD_INIT,
116 : : .m_name = "spiexceptions",
117 : : .m_size = -1,
118 : : .m_methods = PLy_exc_methods,
119 : : };
120 : :
121 : : /*
122 : : * Must have external linkage, because PyMODINIT_FUNC does dllexport on
123 : : * Windows-like platforms.
124 : : */
125 : : PyMODINIT_FUNC
126 : 23 : PyInit_plpy(void)
127 : : {
128 : : PyObject *m;
129 : :
130 : 23 : m = PyModule_Create(&PLy_module);
131 [ - + ]: 23 : if (m == NULL)
132 : 0 : return NULL;
133 : :
134 : 23 : PLy_add_exceptions(m);
135 : :
136 : 23 : PLy_plan_init_type();
137 : 23 : PLy_result_init_type();
138 : 23 : PLy_subtransaction_init_type();
139 : 23 : PLy_cursor_init_type();
140 : :
141 : 23 : return m;
142 : : }
143 : :
144 : : static void
145 : 23 : PLy_add_exceptions(PyObject *plpy)
146 : : {
147 : : PyObject *excmod;
148 : : HASHCTL hash_ctl;
149 : :
150 : 23 : PLy_exc_error = PLy_create_exception("plpy.Error", NULL, NULL,
151 : : "Error", plpy);
152 : 23 : PLy_exc_fatal = PLy_create_exception("plpy.Fatal", NULL, NULL,
153 : : "Fatal", plpy);
154 : 23 : PLy_exc_spi_error = PLy_create_exception("plpy.SPIError", NULL, NULL,
155 : : "SPIError", plpy);
156 : :
157 : 23 : excmod = PyModule_Create(&PLy_exc_module);
158 [ - + ]: 23 : if (excmod == NULL)
159 : 0 : PLy_elog(ERROR, "could not create the spiexceptions module");
160 : :
161 : 23 : hash_ctl.keysize = sizeof(int);
162 : 23 : hash_ctl.entrysize = sizeof(PLyExceptionEntry);
163 : 23 : PLy_spi_exceptions = hash_create("PL/Python SPI exceptions", 256,
164 : : &hash_ctl, HASH_ELEM | HASH_BLOBS);
165 : :
166 : 23 : PLy_generate_spi_exceptions(excmod, PLy_exc_spi_error);
167 : :
168 [ - + ]: 23 : if (PyModule_AddObject(plpy, "spiexceptions", excmod) < 0)
169 : : {
170 : 0 : Py_XDECREF(excmod);
171 : 0 : PLy_elog(ERROR, "could not add the spiexceptions module");
172 : : }
173 : 23 : }
174 : :
175 : : /*
176 : : * Create an exception object and add it to the module
177 : : *
178 : : * The created exception object is also returned.
179 : : */
180 : : static PyObject *
181 : 5842 : PLy_create_exception(char *name, PyObject *base, PyObject *dict,
182 : : const char *modname, PyObject *mod)
183 : : {
184 : : PyObject *exc;
185 : :
186 : 5842 : exc = PyErr_NewException(name, base, dict);
187 [ - + ]: 5842 : if (exc == NULL)
188 : 0 : PLy_elog(ERROR, NULL);
189 : :
190 : : /*
191 : : * PyModule_AddObject() (below) steals the reference to exc, but we also
192 : : * want to return the value from this function, so add another ref to
193 : : * account for that. (The caller will store a pointer to the exception
194 : : * object in some permanent variable.)
195 : : */
196 : : Py_INCREF(exc);
197 : :
198 [ - + ]: 5842 : if (PyModule_AddObject(mod, modname, exc) < 0)
199 : : {
200 : 0 : Py_XDECREF(exc);
201 : 0 : PLy_elog(ERROR, "could not add exception %s", name);
202 : : }
203 : :
204 : 5842 : return exc;
205 : : }
206 : :
207 : : /*
208 : : * Add all the autogenerated exceptions as subclasses of SPIError
209 : : */
210 : : static void
211 : 23 : PLy_generate_spi_exceptions(PyObject *mod, PyObject *base)
212 : : {
213 : : int i;
214 : :
215 [ + + ]: 5796 : for (i = 0; exception_map[i].name != NULL; i++)
216 : : {
217 : : bool found;
218 : : PyObject *exc;
219 : : PLyExceptionEntry *entry;
220 : : PyObject *sqlstate;
221 : 5773 : PyObject *dict = PyDict_New();
222 : :
223 [ - + ]: 5773 : if (dict == NULL)
224 : 0 : PLy_elog(ERROR, NULL);
225 : :
226 : 5773 : sqlstate = PLyUnicode_FromString(unpack_sql_state(exception_map[i].sqlstate));
227 [ - + ]: 5773 : if (sqlstate == NULL)
228 : 0 : PLy_elog(ERROR, "could not generate SPI exceptions");
229 : :
230 : 5773 : PyDict_SetItemString(dict, "sqlstate", sqlstate);
231 : : Py_DECREF(sqlstate);
232 : :
233 : 5773 : exc = PLy_create_exception(exception_map[i].name, base, dict,
234 : 5773 : exception_map[i].classname, mod);
235 : :
236 : 5773 : entry = hash_search(PLy_spi_exceptions, &exception_map[i].sqlstate,
237 : : HASH_ENTER, &found);
238 : : Assert(!found);
239 : 5773 : entry->exc = exc;
240 : : }
241 : 23 : }
242 : :
243 : :
244 : : /*
245 : : * the python interface to the elog function
246 : : * don't confuse these with PLy_elog
247 : : */
248 : : static PyObject *PLy_output(volatile int level, PyObject *self,
249 : : PyObject *args, PyObject *kw);
250 : :
251 : : static PyObject *
252 : 2 : PLy_debug(PyObject *self, PyObject *args, PyObject *kw)
253 : : {
254 : 2 : return PLy_output(DEBUG2, self, args, kw);
255 : : }
256 : :
257 : : static PyObject *
258 : 2 : PLy_log(PyObject *self, PyObject *args, PyObject *kw)
259 : : {
260 : 2 : return PLy_output(LOG, self, args, kw);
261 : : }
262 : :
263 : : static PyObject *
264 : 112 : PLy_info(PyObject *self, PyObject *args, PyObject *kw)
265 : : {
266 : 112 : return PLy_output(INFO, self, args, kw);
267 : : }
268 : :
269 : : static PyObject *
270 : 215 : PLy_notice(PyObject *self, PyObject *args, PyObject *kw)
271 : : {
272 : 215 : return PLy_output(NOTICE, self, args, kw);
273 : : }
274 : :
275 : : static PyObject *
276 : 5 : PLy_warning(PyObject *self, PyObject *args, PyObject *kw)
277 : : {
278 : 5 : return PLy_output(WARNING, self, args, kw);
279 : : }
280 : :
281 : : static PyObject *
282 : 11 : PLy_error(PyObject *self, PyObject *args, PyObject *kw)
283 : : {
284 : 11 : return PLy_output(ERROR, self, args, kw);
285 : : }
286 : :
287 : : static PyObject *
288 : 0 : PLy_fatal(PyObject *self, PyObject *args, PyObject *kw)
289 : : {
290 : 0 : return PLy_output(FATAL, self, args, kw);
291 : : }
292 : :
293 : : static PyObject *
294 : 6 : PLy_quote_literal(PyObject *self, PyObject *args)
295 : : {
296 : : const char *str;
297 : : char *quoted;
298 : : PyObject *ret;
299 : :
300 [ - + ]: 6 : if (!PyArg_ParseTuple(args, "s:quote_literal", &str))
301 : 0 : return NULL;
302 : :
303 : 6 : quoted = quote_literal_cstr(str);
304 : 6 : ret = PLyUnicode_FromString(quoted);
305 : 6 : pfree(quoted);
306 : :
307 : 6 : return ret;
308 : : }
309 : :
310 : : static PyObject *
311 : 6 : PLy_quote_nullable(PyObject *self, PyObject *args)
312 : : {
313 : : const char *str;
314 : : char *quoted;
315 : : PyObject *ret;
316 : :
317 [ - + ]: 6 : if (!PyArg_ParseTuple(args, "z:quote_nullable", &str))
318 : 0 : return NULL;
319 : :
320 [ + + ]: 6 : if (str == NULL)
321 : 1 : return PLyUnicode_FromString("NULL");
322 : :
323 : 5 : quoted = quote_literal_cstr(str);
324 : 5 : ret = PLyUnicode_FromString(quoted);
325 : 5 : pfree(quoted);
326 : :
327 : 5 : return ret;
328 : : }
329 : :
330 : : static PyObject *
331 : 3 : PLy_quote_ident(PyObject *self, PyObject *args)
332 : : {
333 : : const char *str;
334 : : const char *quoted;
335 : : PyObject *ret;
336 : :
337 [ - + ]: 3 : if (!PyArg_ParseTuple(args, "s:quote_ident", &str))
338 : 0 : return NULL;
339 : :
340 : 3 : quoted = quote_identifier(str);
341 : 3 : ret = PLyUnicode_FromString(quoted);
342 : :
343 : 3 : return ret;
344 : : }
345 : :
346 : : /* enforce cast of object to string (returns a palloc'd string or NULL) */
347 : : static char *
348 : 58 : object_to_string(PyObject *obj)
349 : : {
350 [ + - ]: 58 : if (obj)
351 : : {
352 : 58 : PyObject *so = PyObject_Str(obj);
353 : :
354 [ + - ]: 58 : if (so != NULL)
355 : : {
356 : : char *str;
357 : :
358 : 58 : str = PLyUnicode_AsString(so);
359 : : Py_DECREF(so);
360 : :
361 : 58 : return str;
362 : : }
363 : : }
364 : :
365 : 0 : return NULL;
366 : : }
367 : :
368 : : static PyObject *
369 : 347 : PLy_output(volatile int level, PyObject *self, PyObject *args, PyObject *kw)
370 : : {
371 : 347 : int sqlstate = 0;
372 : 347 : char *volatile sqlstatestr = NULL;
373 : 347 : char *volatile message = NULL;
374 : 347 : char *volatile detail = NULL;
375 : 347 : char *volatile hint = NULL;
376 : 347 : char *volatile column_name = NULL;
377 : 347 : char *volatile constraint_name = NULL;
378 : 347 : char *volatile datatype_name = NULL;
379 : 347 : char *volatile table_name = NULL;
380 : 347 : char *volatile schema_name = NULL;
381 : : volatile MemoryContext oldcontext;
382 : : PyObject *key,
383 : : *value;
384 : : PyObject *volatile so;
385 : 347 : Py_ssize_t pos = 0;
386 : :
387 [ + + ]: 347 : if (PyTuple_Size(args) == 1)
388 : : {
389 : : /*
390 : : * Treat single argument specially to avoid undesirable ('tuple',)
391 : : * decoration.
392 : : */
393 : : PyObject *o;
394 : :
395 [ - + ]: 261 : if (!PyArg_UnpackTuple(args, "plpy.elog", 1, 1, &o))
396 : 0 : PLy_elog(ERROR, "could not unpack arguments in plpy.elog");
397 : 261 : so = PyObject_Str(o);
398 : : }
399 : : else
400 : 86 : so = PyObject_Str(args);
401 : :
402 [ + - - + ]: 347 : if (so == NULL || ((message = PLyUnicode_AsString(so)) == NULL))
403 : : {
404 : 0 : level = ERROR;
405 : 0 : message = dgettext(TEXTDOMAIN, "could not parse error message in plpy.elog");
406 : : }
407 : 347 : message = pstrdup(message);
408 : :
409 : 347 : Py_XDECREF(so);
410 : :
411 [ + + ]: 347 : if (kw != NULL)
412 : : {
413 [ + + ]: 80 : while (PyDict_Next(kw, &pos, &key, &value))
414 : : {
415 : 61 : char *keyword = PLyUnicode_AsString(key);
416 : :
417 [ + + ]: 61 : if (strcmp(keyword, "message") == 0)
418 : : {
419 : : /* the message should not be overwritten */
420 [ + + ]: 9 : if (PyTuple_Size(args) != 0)
421 : : {
422 : 2 : PLy_exception_set(PyExc_TypeError, "argument 'message' given by name and position");
423 : 2 : return NULL;
424 : : }
425 : :
426 [ + - ]: 7 : if (message)
427 : 7 : pfree(message);
428 : 7 : message = object_to_string(value);
429 : : }
430 [ + + ]: 52 : else if (strcmp(keyword, "detail") == 0)
431 : 15 : detail = object_to_string(value);
432 [ + + ]: 37 : else if (strcmp(keyword, "hint") == 0)
433 : 7 : hint = object_to_string(value);
434 [ + + ]: 30 : else if (strcmp(keyword, "sqlstate") == 0)
435 : 7 : sqlstatestr = object_to_string(value);
436 [ + + ]: 23 : else if (strcmp(keyword, "schema_name") == 0)
437 : 4 : schema_name = object_to_string(value);
438 [ + + ]: 19 : else if (strcmp(keyword, "table_name") == 0)
439 : 5 : table_name = object_to_string(value);
440 [ + + ]: 14 : else if (strcmp(keyword, "column_name") == 0)
441 : 4 : column_name = object_to_string(value);
442 [ + + ]: 10 : else if (strcmp(keyword, "datatype_name") == 0)
443 : 5 : datatype_name = object_to_string(value);
444 [ + + ]: 5 : else if (strcmp(keyword, "constraint_name") == 0)
445 : 4 : constraint_name = object_to_string(value);
446 : : else
447 : : {
448 : 1 : PLy_exception_set(PyExc_TypeError,
449 : : "'%s' is an invalid keyword argument for this function",
450 : : keyword);
451 : 1 : return NULL;
452 : : }
453 : : }
454 : : }
455 : :
456 [ + + ]: 344 : if (sqlstatestr != NULL)
457 : : {
458 [ + + ]: 7 : if (strlen(sqlstatestr) != 5)
459 : : {
460 : 1 : PLy_exception_set(PyExc_ValueError, "invalid SQLSTATE code");
461 : 1 : return NULL;
462 : : }
463 : :
464 [ - + ]: 6 : if (strspn(sqlstatestr, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") != 5)
465 : : {
466 : 0 : PLy_exception_set(PyExc_ValueError, "invalid SQLSTATE code");
467 : 0 : return NULL;
468 : : }
469 : :
470 : 6 : sqlstate = MAKE_SQLSTATE(sqlstatestr[0],
471 : : sqlstatestr[1],
472 : : sqlstatestr[2],
473 : : sqlstatestr[3],
474 : : sqlstatestr[4]);
475 : : }
476 : :
477 : 343 : oldcontext = CurrentMemoryContext;
478 [ + + ]: 343 : PG_TRY();
479 : : {
480 [ + - ]: 343 : if (message != NULL)
481 : 343 : pg_verifymbstr(message, strlen(message), false);
482 [ + + ]: 343 : if (detail != NULL)
483 : 15 : pg_verifymbstr(detail, strlen(detail), false);
484 [ + + ]: 343 : if (hint != NULL)
485 : 7 : pg_verifymbstr(hint, strlen(hint), false);
486 [ + + ]: 343 : if (schema_name != NULL)
487 : 4 : pg_verifymbstr(schema_name, strlen(schema_name), false);
488 [ + + ]: 343 : if (table_name != NULL)
489 : 5 : pg_verifymbstr(table_name, strlen(table_name), false);
490 [ + + ]: 343 : if (column_name != NULL)
491 : 4 : pg_verifymbstr(column_name, strlen(column_name), false);
492 [ + + ]: 343 : if (datatype_name != NULL)
493 : 5 : pg_verifymbstr(datatype_name, strlen(datatype_name), false);
494 [ + + ]: 343 : if (constraint_name != NULL)
495 : 4 : pg_verifymbstr(constraint_name, strlen(constraint_name), false);
496 : :
497 [ + + + + : 343 : ereport(level,
+ - + + +
+ + + + +
+ + + + +
+ ]
498 : : ((sqlstate != 0) ? errcode(sqlstate) : 0,
499 : : (message != NULL) ? errmsg_internal("%s", message) : 0,
500 : : (detail != NULL) ? errdetail_internal("%s", detail) : 0,
501 : : (hint != NULL) ? errhint("%s", hint) : 0,
502 : : (column_name != NULL) ?
503 : : err_generic_string(PG_DIAG_COLUMN_NAME, column_name) : 0,
504 : : (constraint_name != NULL) ?
505 : : err_generic_string(PG_DIAG_CONSTRAINT_NAME, constraint_name) : 0,
506 : : (datatype_name != NULL) ?
507 : : err_generic_string(PG_DIAG_DATATYPE_NAME, datatype_name) : 0,
508 : : (table_name != NULL) ?
509 : : err_generic_string(PG_DIAG_TABLE_NAME, table_name) : 0,
510 : : (schema_name != NULL) ?
511 : : err_generic_string(PG_DIAG_SCHEMA_NAME, schema_name) : 0));
512 : : }
513 : 11 : PG_CATCH();
514 : : {
515 : : ErrorData *edata;
516 : :
517 : 11 : MemoryContextSwitchTo(oldcontext);
518 : 11 : edata = CopyErrorData();
519 : 11 : FlushErrorState();
520 : :
521 : 11 : PLy_exception_set_with_details(PLy_exc_error, edata);
522 : 11 : FreeErrorData(edata);
523 : :
524 : 11 : return NULL;
525 : : }
526 [ - + ]: 332 : PG_END_TRY();
527 : :
528 : : /*
529 : : * return a legal object so the interpreter will continue on its merry way
530 : : */
531 : 332 : Py_RETURN_NONE;
532 : : }
|
