PostgreSQL Source Code  git master
plpy_plpymodule.c File Reference
#include "postgres.h"
#include "access/xact.h"
#include "mb/pg_wchar.h"
#include "utils/builtins.h"
#include "utils/snapmgr.h"
#include "plpython.h"
#include "plpy_plpymodule.h"
#include "plpy_cursorobject.h"
#include "plpy_elog.h"
#include "plpy_main.h"
#include "plpy_planobject.h"
#include "plpy_resultobject.h"
#include "plpy_spi.h"
#include "plpy_subxactobject.h"
#include "spiexceptions.h"
Include dependency graph for plpy_plpymodule.c:

Go to the source code of this file.

Data Structures

struct  ExceptionMap
 

Typedefs

typedef struct ExceptionMap ExceptionMap
 

Functions

static void PLy_add_exceptions (PyObject *plpy)
 
static PyObject * PLy_create_exception (char *name, PyObject *base, PyObject *dict, const char *modname, PyObject *mod)
 
static void PLy_generate_spi_exceptions (PyObject *mod, PyObject *base)
 
static PyObject * PLy_debug (PyObject *self, PyObject *args, PyObject *kw)
 
static PyObject * PLy_log (PyObject *self, PyObject *args, PyObject *kw)
 
static PyObject * PLy_info (PyObject *self, PyObject *args, PyObject *kw)
 
static PyObject * PLy_notice (PyObject *self, PyObject *args, PyObject *kw)
 
static PyObject * PLy_warning (PyObject *self, PyObject *args, PyObject *kw)
 
static PyObject * PLy_error (PyObject *self, PyObject *args, PyObject *kw)
 
static PyObject * PLy_fatal (PyObject *self, PyObject *args, PyObject *kw)
 
static PyObject * PLy_quote_literal (PyObject *self, PyObject *args)
 
static PyObject * PLy_quote_nullable (PyObject *self, PyObject *args)
 
static PyObject * PLy_quote_ident (PyObject *self, PyObject *args)
 
static PyObject * PLy_commit (PyObject *self, PyObject *args)
 
static PyObject * PLy_rollback (PyObject *self, PyObject *args)
 
void PLy_init_plpy (void)
 
static PyObject * PLy_output (volatile int level, PyObject *self, PyObject *args, PyObject *kw)
 
static char * object_to_string (PyObject *obj)
 

Variables

HTABPLy_spi_exceptions = NULL
 
static const ExceptionMap exception_map []
 
static PyMethodDef PLy_methods []
 
static PyMethodDef PLy_exc_methods []
 

Typedef Documentation

◆ ExceptionMap

typedef struct ExceptionMap ExceptionMap

Function Documentation

◆ object_to_string()

static char* object_to_string ( PyObject *  obj)
static

Definition at line 400 of file plpy_plpymodule.c.

References pstrdup(), and generate_unaccent_rules::str.

Referenced by PLy_output().

401 {
402  if (obj)
403  {
404  PyObject *so = PyObject_Str(obj);
405 
406  if (so != NULL)
407  {
408  char *str;
409 
410  str = pstrdup(PyString_AsString(so));
411  Py_DECREF(so);
412 
413  return str;
414  }
415  }
416 
417  return NULL;
418 }
char * pstrdup(const char *in)
Definition: mcxt.c:1186

◆ PLy_add_exceptions()

static void PLy_add_exceptions ( PyObject *  plpy)
static

Definition at line 193 of file plpy_plpymodule.c.

References HASHCTL::entrysize, ERROR, HASH_BLOBS, hash_create(), HASH_ELEM, HASHCTL::keysize, PLy_create_exception(), PLy_elog, PLy_exc_error, PLy_exc_fatal, PLy_exc_methods, PLy_exc_spi_error, and PLy_generate_spi_exceptions().

Referenced by PLy_init_plpy().

194 {
195  PyObject *excmod;
196  HASHCTL hash_ctl;
197 
198 #if PY_MAJOR_VERSION < 3
199  excmod = Py_InitModule("spiexceptions", PLy_exc_methods);
200 #else
201  excmod = PyModule_Create(&PLy_exc_module);
202 #endif
203  if (excmod == NULL)
204  PLy_elog(ERROR, "could not create the spiexceptions module");
205 
206  /*
207  * PyModule_AddObject does not add a refcount to the object, for some odd
208  * reason; we must do that.
209  */
210  Py_INCREF(excmod);
211  if (PyModule_AddObject(plpy, "spiexceptions", excmod) < 0)
212  PLy_elog(ERROR, "could not add the spiexceptions module");
213 
214  PLy_exc_error = PLy_create_exception("plpy.Error", NULL, NULL,
215  "Error", plpy);
216  PLy_exc_fatal = PLy_create_exception("plpy.Fatal", NULL, NULL,
217  "Fatal", plpy);
218  PLy_exc_spi_error = PLy_create_exception("plpy.SPIError", NULL, NULL,
219  "SPIError", plpy);
220 
221  memset(&hash_ctl, 0, sizeof(hash_ctl));
222  hash_ctl.keysize = sizeof(int);
223  hash_ctl.entrysize = sizeof(PLyExceptionEntry);
224  PLy_spi_exceptions = hash_create("PL/Python SPI exceptions", 256,
225  &hash_ctl, HASH_ELEM | HASH_BLOBS);
226 
228 }
#define HASH_ELEM
Definition: hsearch.h:87
Size entrysize
Definition: hsearch.h:73
PyObject * PLy_exc_error
Definition: plpy_elog.c:19
static void PLy_generate_spi_exceptions(PyObject *mod, PyObject *base)
#define ERROR
Definition: elog.h:43
#define PLy_elog
static PyObject * PLy_create_exception(char *name, PyObject *base, PyObject *dict, const char *modname, PyObject *mod)
#define HASH_BLOBS
Definition: hsearch.h:88
HTAB * hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
Definition: dynahash.c:316
Size keysize
Definition: hsearch.h:72
static PyMethodDef PLy_exc_methods[]
PyObject * PLy_exc_fatal
Definition: plpy_elog.c:20
struct PLyExceptionEntry PLyExceptionEntry
HTAB * PLy_spi_exceptions
PyObject * PLy_exc_spi_error
Definition: plpy_elog.c:21

◆ PLy_commit()

static PyObject * PLy_commit ( PyObject *  self,
PyObject *  args 
)
static

Definition at line 587 of file plpy_plpymodule.c.

References PLy_current_execution_context(), PLyExecutionContext::scratch_ctx, SPI_commit(), and SPI_start_transaction().

588 {
590 
591  SPI_commit();
593 
594  /* was cleared at transaction end, reset pointer */
595  exec_ctx->scratch_ctx = NULL;
596 
597  Py_RETURN_NONE;
598 }
MemoryContext scratch_ctx
Definition: plpy_main.h:21
PLyExecutionContext * PLy_current_execution_context(void)
Definition: plpy_main.c:414
void SPI_commit(void)
Definition: spi.c:278
void SPI_start_transaction(void)
Definition: spi.c:212

◆ PLy_create_exception()

static PyObject * PLy_create_exception ( char *  name,
PyObject *  base,
PyObject *  dict,
const char *  modname,
PyObject *  mod 
)
static

Definition at line 234 of file plpy_plpymodule.c.

References ERROR, and PLy_elog.

Referenced by PLy_add_exceptions(), and PLy_generate_spi_exceptions().

236 {
237  PyObject *exc;
238 
239  exc = PyErr_NewException(name, base, dict);
240  if (exc == NULL)
241  PLy_elog(ERROR, NULL);
242 
243  /*
244  * PyModule_AddObject does not add a refcount to the object, for some odd
245  * reason; we must do that.
246  */
247  Py_INCREF(exc);
248  PyModule_AddObject(mod, modname, exc);
249 
250  /*
251  * The caller will also store a pointer to the exception object in some
252  * permanent variable, so add another ref to account for that. This is
253  * probably excessively paranoid, but let's be sure.
254  */
255  Py_INCREF(exc);
256  return exc;
257 }
#define ERROR
Definition: elog.h:43
#define PLy_elog
const char * name
Definition: encode.c:521

◆ PLy_debug()

static PyObject * PLy_debug ( PyObject *  self,
PyObject *  args,
PyObject *  kw 
)
static

Definition at line 304 of file plpy_plpymodule.c.

References DEBUG2, and PLy_output().

305 {
306  return PLy_output(DEBUG2, self, args, kw);
307 }
#define DEBUG2
Definition: elog.h:24
static PyObject * PLy_output(volatile int level, PyObject *self, PyObject *args, PyObject *kw)

◆ PLy_error()

static PyObject * PLy_error ( PyObject *  self,
PyObject *  args,
PyObject *  kw 
)
static

Definition at line 334 of file plpy_plpymodule.c.

References ERROR, and PLy_output().

335 {
336  return PLy_output(ERROR, self, args, kw);
337 }
#define ERROR
Definition: elog.h:43
static PyObject * PLy_output(volatile int level, PyObject *self, PyObject *args, PyObject *kw)

◆ PLy_fatal()

static PyObject * PLy_fatal ( PyObject *  self,
PyObject *  args,
PyObject *  kw 
)
static

Definition at line 340 of file plpy_plpymodule.c.

References FATAL, and PLy_output().

341 {
342  return PLy_output(FATAL, self, args, kw);
343 }
#define FATAL
Definition: elog.h:52
static PyObject * PLy_output(volatile int level, PyObject *self, PyObject *args, PyObject *kw)

◆ PLy_generate_spi_exceptions()

static void PLy_generate_spi_exceptions ( PyObject *  mod,
PyObject *  base 
)
static

Definition at line 263 of file plpy_plpymodule.c.

References generate_unaccent_rules::args, Assert, ExceptionMap::classname, ERROR, PLyExceptionEntry::exc, HASH_ENTER, hash_search(), i, ExceptionMap::name, PLy_create_exception(), PLy_elog, PLy_output(), ExceptionMap::sqlstate, and unpack_sql_state().

Referenced by PLy_add_exceptions().

264 {
265  int i;
266 
267  for (i = 0; exception_map[i].name != NULL; i++)
268  {
269  bool found;
270  PyObject *exc;
271  PLyExceptionEntry *entry;
272  PyObject *sqlstate;
273  PyObject *dict = PyDict_New();
274 
275  if (dict == NULL)
276  PLy_elog(ERROR, NULL);
277 
278  sqlstate = PyString_FromString(unpack_sql_state(exception_map[i].sqlstate));
279  if (sqlstate == NULL)
280  PLy_elog(ERROR, "could not generate SPI exceptions");
281 
282  PyDict_SetItemString(dict, "sqlstate", sqlstate);
283  Py_DECREF(sqlstate);
284 
285  exc = PLy_create_exception(exception_map[i].name, base, dict,
286  exception_map[i].classname, mod);
287 
288  entry = hash_search(PLy_spi_exceptions, &exception_map[i].sqlstate,
289  HASH_ENTER, &found);
290  Assert(!found);
291  entry->exc = exc;
292  }
293 }
char * unpack_sql_state(int sql_state)
Definition: elog.c:2831
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:906
#define ERROR
Definition: elog.h:43
#define PLy_elog
static const ExceptionMap exception_map[]
static PyObject * PLy_create_exception(char *name, PyObject *base, PyObject *dict, const char *modname, PyObject *mod)
#define Assert(condition)
Definition: c.h:732
HTAB * PLy_spi_exceptions
const char * name
Definition: encode.c:521
int i
PyObject * exc
Definition: plpy_spi.h:19

◆ PLy_info()

static PyObject * PLy_info ( PyObject *  self,
PyObject *  args,
PyObject *  kw 
)
static

Definition at line 316 of file plpy_plpymodule.c.

References INFO, and PLy_output().

317 {
318  return PLy_output(INFO, self, args, kw);
319 }
#define INFO
Definition: elog.h:33
static PyObject * PLy_output(volatile int level, PyObject *self, PyObject *args, PyObject *kw)

◆ PLy_init_plpy()

void PLy_init_plpy ( void  )

Definition at line 151 of file plpy_plpymodule.c.

References ERROR, PLy_add_exceptions(), PLy_cursor_init_type(), PLy_elog, PLy_methods, PLy_plan_init_type(), PLy_result_init_type(), and PLy_subtransaction_init_type().

Referenced by PLy_initialize().

152 {
153  PyObject *main_mod,
154  *main_dict,
155  *plpy_mod;
156 
157 #if PY_MAJOR_VERSION < 3
158  PyObject *plpy;
159 #endif
160 
161  /*
162  * initialize plpy module
163  */
168 
169 #if PY_MAJOR_VERSION >= 3
170  PyModule_Create(&PLy_module);
171  /* for Python 3 we initialized the exceptions in PyInit_plpy */
172 #else
173  plpy = Py_InitModule("plpy", PLy_methods);
174  PLy_add_exceptions(plpy);
175 #endif
176 
177  /* PyDict_SetItemString(plpy, "PlanType", (PyObject *) &PLy_PlanType); */
178 
179  /*
180  * initialize main module, and add plpy
181  */
182  main_mod = PyImport_AddModule("__main__");
183  main_dict = PyModule_GetDict(main_mod);
184  plpy_mod = PyImport_AddModule("plpy");
185  if (plpy_mod == NULL)
186  PLy_elog(ERROR, "could not import \"plpy\" module");
187  PyDict_SetItemString(main_dict, "plpy", plpy_mod);
188  if (PyErr_Occurred())
189  PLy_elog(ERROR, "could not import \"plpy\" module");
190 }
void PLy_plan_init_type(void)
static void PLy_add_exceptions(PyObject *plpy)
#define ERROR
Definition: elog.h:43
void PLy_cursor_init_type(void)
void PLy_subtransaction_init_type(void)
#define PLy_elog
void PLy_result_init_type(void)
static PyMethodDef PLy_methods[]

◆ PLy_log()

static PyObject * PLy_log ( PyObject *  self,
PyObject *  args,
PyObject *  kw 
)
static

Definition at line 310 of file plpy_plpymodule.c.

References LOG, and PLy_output().

311 {
312  return PLy_output(LOG, self, args, kw);
313 }
#define LOG
Definition: elog.h:26
static PyObject * PLy_output(volatile int level, PyObject *self, PyObject *args, PyObject *kw)

◆ PLy_notice()

static PyObject * PLy_notice ( PyObject *  self,
PyObject *  args,
PyObject *  kw 
)
static

Definition at line 322 of file plpy_plpymodule.c.

References NOTICE, and PLy_output().

323 {
324  return PLy_output(NOTICE, self, args, kw);
325 }
static PyObject * PLy_output(volatile int level, PyObject *self, PyObject *args, PyObject *kw)
#define NOTICE
Definition: elog.h:37

◆ PLy_output()

static PyObject * PLy_output ( volatile int  level,
PyObject *  self,
PyObject *  args,
PyObject *  kw 
)
static

Definition at line 421 of file plpy_plpymodule.c.

References CopyErrorData(), CurrentMemoryContext, dgettext, ereport, err_generic_string(), errcode(), errdetail_internal(), errhint(), errmsg_internal(), ERROR, FlushErrorState(), FreeErrorData(), sort-test::key, MAKE_SQLSTATE, MemoryContextSwitchTo(), object_to_string(), pfree(), PG_CATCH, PG_DIAG_COLUMN_NAME, PG_DIAG_CONSTRAINT_NAME, PG_DIAG_DATATYPE_NAME, PG_DIAG_SCHEMA_NAME, PG_DIAG_TABLE_NAME, PG_END_TRY, PG_TRY, pg_verifymbstr(), PLy_elog, PLy_exc_error, PLy_exception_set(), PLy_exception_set_with_details(), pstrdup(), ExceptionMap::sqlstate, TEXTDOMAIN, and value.

Referenced by PLy_debug(), PLy_error(), PLy_fatal(), PLy_generate_spi_exceptions(), PLy_info(), PLy_log(), PLy_notice(), and PLy_warning().

422 {
423  int sqlstate = 0;
424  char *volatile sqlstatestr = NULL;
425  char *volatile message = NULL;
426  char *volatile detail = NULL;
427  char *volatile hint = NULL;
428  char *volatile column_name = NULL;
429  char *volatile constraint_name = NULL;
430  char *volatile datatype_name = NULL;
431  char *volatile table_name = NULL;
432  char *volatile schema_name = NULL;
433  volatile MemoryContext oldcontext;
434  PyObject *key,
435  *value;
436  PyObject *volatile so;
437  Py_ssize_t pos = 0;
438 
439  if (PyTuple_Size(args) == 1)
440  {
441  /*
442  * Treat single argument specially to avoid undesirable ('tuple',)
443  * decoration.
444  */
445  PyObject *o;
446 
447  if (!PyArg_UnpackTuple(args, "plpy.elog", 1, 1, &o))
448  PLy_elog(ERROR, "could not unpack arguments in plpy.elog");
449  so = PyObject_Str(o);
450  }
451  else
452  so = PyObject_Str(args);
453 
454  if (so == NULL || ((message = PyString_AsString(so)) == NULL))
455  {
456  level = ERROR;
457  message = dgettext(TEXTDOMAIN, "could not parse error message in plpy.elog");
458  }
459  message = pstrdup(message);
460 
461  Py_XDECREF(so);
462 
463  if (kw != NULL)
464  {
465  while (PyDict_Next(kw, &pos, &key, &value))
466  {
467  char *keyword = PyString_AsString(key);
468 
469  if (strcmp(keyword, "message") == 0)
470  {
471  /* the message should not be overwritten */
472  if (PyTuple_Size(args) != 0)
473  {
474  PLy_exception_set(PyExc_TypeError, "argument 'message' given by name and position");
475  return NULL;
476  }
477 
478  if (message)
479  pfree(message);
480  message = object_to_string(value);
481  }
482  else if (strcmp(keyword, "detail") == 0)
483  detail = object_to_string(value);
484  else if (strcmp(keyword, "hint") == 0)
485  hint = object_to_string(value);
486  else if (strcmp(keyword, "sqlstate") == 0)
487  sqlstatestr = object_to_string(value);
488  else if (strcmp(keyword, "schema_name") == 0)
489  schema_name = object_to_string(value);
490  else if (strcmp(keyword, "table_name") == 0)
491  table_name = object_to_string(value);
492  else if (strcmp(keyword, "column_name") == 0)
493  column_name = object_to_string(value);
494  else if (strcmp(keyword, "datatype_name") == 0)
495  datatype_name = object_to_string(value);
496  else if (strcmp(keyword, "constraint_name") == 0)
497  constraint_name = object_to_string(value);
498  else
499  {
500  PLy_exception_set(PyExc_TypeError,
501  "'%s' is an invalid keyword argument for this function",
502  keyword);
503  return NULL;
504  }
505  }
506  }
507 
508  if (sqlstatestr != NULL)
509  {
510  if (strlen(sqlstatestr) != 5)
511  {
512  PLy_exception_set(PyExc_ValueError, "invalid SQLSTATE code");
513  return NULL;
514  }
515 
516  if (strspn(sqlstatestr, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") != 5)
517  {
518  PLy_exception_set(PyExc_ValueError, "invalid SQLSTATE code");
519  return NULL;
520  }
521 
522  sqlstate = MAKE_SQLSTATE(sqlstatestr[0],
523  sqlstatestr[1],
524  sqlstatestr[2],
525  sqlstatestr[3],
526  sqlstatestr[4]);
527  }
528 
529  oldcontext = CurrentMemoryContext;
530  PG_TRY();
531  {
532  if (message != NULL)
533  pg_verifymbstr(message, strlen(message), false);
534  if (detail != NULL)
535  pg_verifymbstr(detail, strlen(detail), false);
536  if (hint != NULL)
537  pg_verifymbstr(hint, strlen(hint), false);
538  if (schema_name != NULL)
539  pg_verifymbstr(schema_name, strlen(schema_name), false);
540  if (table_name != NULL)
541  pg_verifymbstr(table_name, strlen(table_name), false);
542  if (column_name != NULL)
543  pg_verifymbstr(column_name, strlen(column_name), false);
544  if (datatype_name != NULL)
545  pg_verifymbstr(datatype_name, strlen(datatype_name), false);
546  if (constraint_name != NULL)
547  pg_verifymbstr(constraint_name, strlen(constraint_name), false);
548 
549  ereport(level,
550  ((sqlstate != 0) ? errcode(sqlstate) : 0,
551  (message != NULL) ? errmsg_internal("%s", message) : 0,
552  (detail != NULL) ? errdetail_internal("%s", detail) : 0,
553  (hint != NULL) ? errhint("%s", hint) : 0,
554  (column_name != NULL) ?
555  err_generic_string(PG_DIAG_COLUMN_NAME, column_name) : 0,
556  (constraint_name != NULL) ?
557  err_generic_string(PG_DIAG_CONSTRAINT_NAME, constraint_name) : 0,
558  (datatype_name != NULL) ?
559  err_generic_string(PG_DIAG_DATATYPE_NAME, datatype_name) : 0,
560  (table_name != NULL) ?
561  err_generic_string(PG_DIAG_TABLE_NAME, table_name) : 0,
562  (schema_name != NULL) ?
563  err_generic_string(PG_DIAG_SCHEMA_NAME, schema_name) : 0));
564  }
565  PG_CATCH();
566  {
567  ErrorData *edata;
568 
569  MemoryContextSwitchTo(oldcontext);
570  edata = CopyErrorData();
571  FlushErrorState();
572 
574  FreeErrorData(edata);
575 
576  return NULL;
577  }
578  PG_END_TRY();
579 
580  /*
581  * return a legal object so the interpreter will continue on its merry way
582  */
583  Py_RETURN_NONE;
584 }
int errhint(const char *fmt,...)
Definition: elog.c:974
#define PG_DIAG_SCHEMA_NAME
Definition: postgres_ext.h:65
#define TEXTDOMAIN
Definition: elog.h:144
ErrorData * CopyErrorData(void)
Definition: elog.c:1484
#define PG_DIAG_COLUMN_NAME
Definition: postgres_ext.h:67
#define MAKE_SQLSTATE(ch1, ch2, ch3, ch4, ch5)
Definition: elog.h:62
char * pstrdup(const char *in)
Definition: mcxt.c:1186
#define PG_DIAG_TABLE_NAME
Definition: postgres_ext.h:66
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
static struct @145 value
int errcode(int sqlerrcode)
Definition: elog.c:570
PyObject * PLy_exc_error
Definition: plpy_elog.c:19
void PLy_exception_set(PyObject *exc, const char *fmt,...)
Definition: plpy_elog.c:502
void FlushErrorState(void)
Definition: elog.c:1574
int Py_ssize_t
Definition: plpython.h:66
int errdetail_internal(const char *fmt,...)
Definition: elog.c:887
void pfree(void *pointer)
Definition: mcxt.c:1056
void FreeErrorData(ErrorData *edata)
Definition: elog.c:1538
#define ERROR
Definition: elog.h:43
#define PLy_elog
void PLy_exception_set_with_details(PyObject *excclass, ErrorData *edata)
Definition: plpy_elog.c:534
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
#define ereport(elevel, rest)
Definition: elog.h:141
#define dgettext(d, x)
Definition: c.h:1102
#define PG_DIAG_DATATYPE_NAME
Definition: postgres_ext.h:68
#define PG_DIAG_CONSTRAINT_NAME
Definition: postgres_ext.h:69
int errmsg_internal(const char *fmt,...)
Definition: elog.c:814
#define PG_CATCH()
Definition: elog.h:310
bool pg_verifymbstr(const char *mbstr, int len, bool noError)
Definition: wchar.c:1914
int err_generic_string(int field, const char *str)
Definition: elog.c:1178
#define PG_TRY()
Definition: elog.h:301
static char * object_to_string(PyObject *obj)
#define PG_END_TRY()
Definition: elog.h:317

◆ PLy_quote_ident()

static PyObject * PLy_quote_ident ( PyObject *  self,
PyObject *  args 
)
static

Definition at line 383 of file plpy_plpymodule.c.

References quote_identifier(), and generate_unaccent_rules::str.

384 {
385  const char *str;
386  const char *quoted;
387  PyObject *ret;
388 
389  if (!PyArg_ParseTuple(args, "s:quote_ident", &str))
390  return NULL;
391 
392  quoted = quote_identifier(str);
393  ret = PyString_FromString(quoted);
394 
395  return ret;
396 }
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:10628

◆ PLy_quote_literal()

static PyObject * PLy_quote_literal ( PyObject *  self,
PyObject *  args 
)
static

Definition at line 346 of file plpy_plpymodule.c.

References pfree(), quote_literal_cstr(), and generate_unaccent_rules::str.

347 {
348  const char *str;
349  char *quoted;
350  PyObject *ret;
351 
352  if (!PyArg_ParseTuple(args, "s:quote_literal", &str))
353  return NULL;
354 
355  quoted = quote_literal_cstr(str);
356  ret = PyString_FromString(quoted);
357  pfree(quoted);
358 
359  return ret;
360 }
char * quote_literal_cstr(const char *rawstr)
Definition: quote.c:102
void pfree(void *pointer)
Definition: mcxt.c:1056

◆ PLy_quote_nullable()

static PyObject * PLy_quote_nullable ( PyObject *  self,
PyObject *  args 
)
static

Definition at line 363 of file plpy_plpymodule.c.

References pfree(), quote_literal_cstr(), and generate_unaccent_rules::str.

364 {
365  const char *str;
366  char *quoted;
367  PyObject *ret;
368 
369  if (!PyArg_ParseTuple(args, "z:quote_nullable", &str))
370  return NULL;
371 
372  if (str == NULL)
373  return PyString_FromString("NULL");
374 
375  quoted = quote_literal_cstr(str);
376  ret = PyString_FromString(quoted);
377  pfree(quoted);
378 
379  return ret;
380 }
char * quote_literal_cstr(const char *rawstr)
Definition: quote.c:102
void pfree(void *pointer)
Definition: mcxt.c:1056

◆ PLy_rollback()

static PyObject * PLy_rollback ( PyObject *  self,
PyObject *  args 
)
static

Definition at line 601 of file plpy_plpymodule.c.

References PLy_current_execution_context(), PLyExecutionContext::scratch_ctx, SPI_rollback(), and SPI_start_transaction().

602 {
604 
605  SPI_rollback();
607 
608  /* was cleared at transaction end, reset pointer */
609  exec_ctx->scratch_ctx = NULL;
610 
611  Py_RETURN_NONE;
612 }
MemoryContext scratch_ctx
Definition: plpy_main.h:21
PLyExecutionContext * PLy_current_execution_context(void)
Definition: plpy_main.c:414
void SPI_rollback(void)
Definition: spi.c:333
void SPI_start_transaction(void)
Definition: spi.c:212

◆ PLy_warning()

static PyObject * PLy_warning ( PyObject *  self,
PyObject *  args,
PyObject *  kw 
)
static

Definition at line 328 of file plpy_plpymodule.c.

References PLy_output(), and WARNING.

329 {
330  return PLy_output(WARNING, self, args, kw);
331 }
static PyObject * PLy_output(volatile int level, PyObject *self, PyObject *args, PyObject *kw)
#define WARNING
Definition: elog.h:40

Variable Documentation

◆ exception_map

const ExceptionMap exception_map[]
static
Initial value:
= {
{NULL, NULL, 0}
}

Definition at line 59 of file plpy_plpymodule.c.

◆ PLy_exc_methods

PyMethodDef PLy_exc_methods[]
static
Initial value:
= {
{NULL, NULL, 0, NULL}
}

Definition at line 112 of file plpy_plpymodule.c.

Referenced by PLy_add_exceptions().

◆ PLy_methods

PyMethodDef PLy_methods[]
static

Definition at line 64 of file plpy_plpymodule.c.

Referenced by PLy_init_plpy().

◆ PLy_spi_exceptions

HTAB* PLy_spi_exceptions = NULL

Definition at line 27 of file plpy_plpymodule.c.

Referenced by PLy_spi_subtransaction_abort().