plpy_plpymodule.c File Reference

#include "postgres.h"
#include "mb/pg_wchar.h"
#include "plpy_cursorobject.h"
#include "plpy_elog.h"
#include "plpy_planobject.h"
#include "plpy_plpymodule.h"
#include "plpy_resultobject.h"
#include "plpy_spi.h"
#include "plpy_subxactobject.h"
#include "plpy_util.h"
#include "utils/builtins.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)
PyMODINIT_FUNC	PyInit_plpy (void)
static PyObject *	PLy_output (volatile int level, PyObject *self, PyObject *args, PyObject *kw)
static char *	object_to_string (PyObject *obj)

Variables
HTAB *	PLy_spi_exceptions = NULL
static const ExceptionMap	exception_map []
static PyMethodDef	PLy_methods []
static PyMethodDef	PLy_exc_methods []
static PyModuleDef	PLy_module
static PyModuleDef	PLy_exc_module

Typedef Documentation

ExceptionMap

typedef struct ExceptionMap ExceptionMap

Function Documentation

object_to_string()

static char * object_to_string ( PyObject *  obj )

static

Definition at line 348 of file plpy_plpymodule.c.

{
    if (obj)
    {
        PyObject   *so = PyObject_Str(obj);
 
        if (so != NULL)
        {
            char       *str;
 
            str = PLyUnicode_AsString(so);
            Py_DECREF(so);
 
            return str;
        }
    }
 
    return NULL;
}

References fb(), PLyUnicode_AsString(), and str.

Referenced by PLy_output().

PLy_add_exceptions()

static void PLy_add_exceptions ( PyObject *  plpy )

static

Definition at line 145 of file plpy_plpymodule.c.

{
    PyObject   *excmod;
    HASHCTL     hash_ctl;
 
    PLy_exc_error = PLy_create_exception("plpy.Error", NULL, NULL,
                                         "Error", plpy);
    PLy_exc_fatal = PLy_create_exception("plpy.Fatal", NULL, NULL,
                                         "Fatal", plpy);
    PLy_exc_spi_error = PLy_create_exception("plpy.SPIError", NULL, NULL,
                                             "SPIError", plpy);
 
    excmod = PyModule_Create(&PLy_exc_module);
    if (excmod == NULL)
        PLy_elog(ERROR, "could not create the spiexceptions module");
 
    hash_ctl.keysize = sizeof(int);
    hash_ctl.entrysize = sizeof(PLyExceptionEntry);
    PLy_spi_exceptions = hash_create("PL/Python SPI exceptions", 256,
                                     &hash_ctl, HASH_ELEM | HASH_BLOBS);
 
    PLy_generate_spi_exceptions(excmod, PLy_exc_spi_error);
 
    if (PyModule_AddObject(plpy, "spiexceptions", excmod) < 0)
    {
        Py_XDECREF(excmod);
        PLy_elog(ERROR, "could not add the spiexceptions module");
    }
}

References ERROR, fb(), HASH_BLOBS, hash_create(), HASH_ELEM, PLy_create_exception(), PLy_elog, PLy_exc_error, PLy_exc_fatal, PLy_exc_module, PLy_exc_spi_error, PLy_generate_spi_exceptions(), and PLy_spi_exceptions.

Referenced by PyInit_plpy().

PLy_create_exception()

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

static

Definition at line 181 of file plpy_plpymodule.c.

{
    PyObject   *exc;
 
    exc = PyErr_NewException(name, base, dict);
    if (exc == NULL)
        PLy_elog(ERROR, NULL);
 
    /*
     * PyModule_AddObject() (below) steals the reference to exc, but we also
     * want to return the value from this function, so add another ref to
     * account for that.  (The caller will store a pointer to the exception
     * object in some permanent variable.)
     */
    Py_INCREF(exc);
 
    if (PyModule_AddObject(mod, modname, exc) < 0)
    {
        Py_XDECREF(exc);
        PLy_elog(ERROR, "could not add exception %s", name);
    }
 
    return exc;
}

References ERROR, fb(), name, and PLy_elog.

Referenced by PLy_add_exceptions(), and PLy_generate_spi_exceptions().

PLy_debug()

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

static

Definition at line 252 of file plpy_plpymodule.c.

{
    return PLy_output(DEBUG2, self, args, kw);
}

References DEBUG2, fb(), and PLy_output().

PLy_error()

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

static

Definition at line 282 of file plpy_plpymodule.c.

{
    return PLy_output(ERROR, self, args, kw);
}

References ERROR, fb(), and PLy_output().

PLy_fatal()

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

static

Definition at line 288 of file plpy_plpymodule.c.

{
    return PLy_output(FATAL, self, args, kw);
}

References FATAL, fb(), and PLy_output().

PLy_generate_spi_exceptions()

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

static

Definition at line 211 of file plpy_plpymodule.c.

{
    int         i;
 
    for (i = 0; exception_map[i].name != NULL; i++)
    {
        bool        found;
        PyObject   *exc;
        PLyExceptionEntry *entry;
        PyObject   *sqlstate;
        PyObject   *dict = PyDict_New();
 
        if (dict == NULL)
            PLy_elog(ERROR, NULL);
 
        sqlstate = PLyUnicode_FromString(unpack_sql_state(exception_map[i].sqlstate));
        if (sqlstate == NULL)
            PLy_elog(ERROR, "could not generate SPI exceptions");
 
        PyDict_SetItemString(dict, "sqlstate", sqlstate);
        Py_DECREF(sqlstate);
 
        exc = PLy_create_exception(exception_map[i].name, base, dict,
                                   exception_map[i].classname, mod);
 
        entry = hash_search(PLy_spi_exceptions, &exception_map[i].sqlstate,
                            HASH_ENTER, &found);
        Assert(!found);
        entry->exc = exc;
    }
}

References Assert, ERROR, PLyExceptionEntry::exc, exception_map, fb(), HASH_ENTER, hash_search(), i, name, ExceptionMap::name, PLy_create_exception(), PLy_elog, PLy_spi_exceptions, PLyUnicode_FromString(), and unpack_sql_state().

Referenced by PLy_add_exceptions().

PLy_info()

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

static

Definition at line 264 of file plpy_plpymodule.c.

{
    return PLy_output(INFO, self, args, kw);
}

References fb(), INFO, and PLy_output().

PLy_log()

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

static

Definition at line 258 of file plpy_plpymodule.c.

{
    return PLy_output(LOG, self, args, kw);
}

References fb(), LOG, and PLy_output().

PLy_notice()

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

static

Definition at line 270 of file plpy_plpymodule.c.

{
    return PLy_output(NOTICE, self, args, kw);
}

References fb(), NOTICE, and PLy_output().

PLy_output()

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

static

Definition at line 369 of file plpy_plpymodule.c.

{
    int         sqlstate = 0;
    char       *volatile sqlstatestr = NULL;
    char       *volatile message = NULL;
    char       *volatile detail = NULL;
    char       *volatile hint = NULL;
    char       *volatile column_name = NULL;
    char       *volatile constraint_name = NULL;
    char       *volatile datatype_name = NULL;
    char       *volatile table_name = NULL;
    char       *volatile schema_name = NULL;
    volatile MemoryContext oldcontext;
    PyObject   *key,
               *value;
    PyObject   *volatile so;
    Py_ssize_t  pos = 0;
 
    if (PyTuple_Size(args) == 1)
    {
        /*
         * Treat single argument specially to avoid undesirable ('tuple',)
         * decoration.
         */
        PyObject   *o;
 
        if (!PyArg_UnpackTuple(args, "plpy.elog", 1, 1, &o))
            PLy_elog(ERROR, "could not unpack arguments in plpy.elog");
        so = PyObject_Str(o);
    }
    else
        so = PyObject_Str(args);
 
    if (so == NULL || ((message = PLyUnicode_AsString(so)) == NULL))
    {
        level = ERROR;
        message = dgettext(TEXTDOMAIN, "could not parse error message in plpy.elog");
    }
    message = pstrdup(message);
 
    Py_XDECREF(so);
 
    if (kw != NULL)
    {
        while (PyDict_Next(kw, &pos, &key, &value))
        {
            char       *keyword = PLyUnicode_AsString(key);
 
            if (strcmp(keyword, "message") == 0)
            {
                /* the message should not be overwritten */
                if (PyTuple_Size(args) != 0)
                {
                    PLy_exception_set(PyExc_TypeError, "argument 'message' given by name and position");
                    return NULL;
                }
 
                if (message)
                    pfree(message);
                message = object_to_string(value);
            }
            else if (strcmp(keyword, "detail") == 0)
                detail = object_to_string(value);
            else if (strcmp(keyword, "hint") == 0)
                hint = object_to_string(value);
            else if (strcmp(keyword, "sqlstate") == 0)
                sqlstatestr = object_to_string(value);
            else if (strcmp(keyword, "schema_name") == 0)
                schema_name = object_to_string(value);
            else if (strcmp(keyword, "table_name") == 0)
                table_name = object_to_string(value);
            else if (strcmp(keyword, "column_name") == 0)
                column_name = object_to_string(value);
            else if (strcmp(keyword, "datatype_name") == 0)
                datatype_name = object_to_string(value);
            else if (strcmp(keyword, "constraint_name") == 0)
                constraint_name = object_to_string(value);
            else
            {
                PLy_exception_set(PyExc_TypeError,
                                  "'%s' is an invalid keyword argument for this function",
                                  keyword);
                return NULL;
            }
        }
    }
 
    if (sqlstatestr != NULL)
    {
        if (strlen(sqlstatestr) != 5)
        {
            PLy_exception_set(PyExc_ValueError, "invalid SQLSTATE code");
            return NULL;
        }
 
        if (strspn(sqlstatestr, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") != 5)
        {
            PLy_exception_set(PyExc_ValueError, "invalid SQLSTATE code");
            return NULL;
        }
 
        sqlstate = MAKE_SQLSTATE(sqlstatestr[0],
                                 sqlstatestr[1],
                                 sqlstatestr[2],
                                 sqlstatestr[3],
                                 sqlstatestr[4]);
    }
 
    oldcontext = CurrentMemoryContext;
    PG_TRY();
    {
        if (message != NULL)
            pg_verifymbstr(message, strlen(message), false);
        if (detail != NULL)
            pg_verifymbstr(detail, strlen(detail), false);
        if (hint != NULL)
            pg_verifymbstr(hint, strlen(hint), false);
        if (schema_name != NULL)
            pg_verifymbstr(schema_name, strlen(schema_name), false);
        if (table_name != NULL)
            pg_verifymbstr(table_name, strlen(table_name), false);
        if (column_name != NULL)
            pg_verifymbstr(column_name, strlen(column_name), false);
        if (datatype_name != NULL)
            pg_verifymbstr(datatype_name, strlen(datatype_name), false);
        if (constraint_name != NULL)
            pg_verifymbstr(constraint_name, strlen(constraint_name), false);
 
        ereport(level,
                ((sqlstate != 0) ? errcode(sqlstate) : 0,
                 (message != NULL) ? errmsg_internal("%s", message) : 0,
                 (detail != NULL) ? errdetail_internal("%s", detail) : 0,
                 (hint != NULL) ? errhint("%s", hint) : 0,
                 (column_name != NULL) ?
                 err_generic_string(PG_DIAG_COLUMN_NAME, column_name) : 0,
                 (constraint_name != NULL) ?
                 err_generic_string(PG_DIAG_CONSTRAINT_NAME, constraint_name) : 0,
                 (datatype_name != NULL) ?
                 err_generic_string(PG_DIAG_DATATYPE_NAME, datatype_name) : 0,
                 (table_name != NULL) ?
                 err_generic_string(PG_DIAG_TABLE_NAME, table_name) : 0,
                 (schema_name != NULL) ?
                 err_generic_string(PG_DIAG_SCHEMA_NAME, schema_name) : 0));
    }
    PG_CATCH();
    {
        ErrorData  *edata;
 
        MemoryContextSwitchTo(oldcontext);
        edata = CopyErrorData();
        FlushErrorState();
 
        PLy_exception_set_with_details(PLy_exc_error, edata);
        FreeErrorData(edata);
 
        return NULL;
    }
    PG_END_TRY();
 
    /*
     * return a legal object so the interpreter will continue on its merry way
     */
    Py_RETURN_NONE;
}

References CopyErrorData(), CurrentMemoryContext, dgettext, ereport, err_generic_string(), errcode(), errdetail_internal(), errhint(), errmsg_internal(), ERROR, fb(), FlushErrorState(), FreeErrorData(), 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(), PLyUnicode_AsString(), pstrdup(), TEXTDOMAIN, and value.

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

PLy_quote_ident()

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

static

Definition at line 331 of file plpy_plpymodule.c.

{
    const char *str;
    const char *quoted;
    PyObject   *ret;
 
    if (!PyArg_ParseTuple(args, "s:quote_ident", &str))
        return NULL;
 
    quoted = quote_identifier(str);
    ret = PLyUnicode_FromString(quoted);
 
    return ret;
}

References fb(), PLyUnicode_FromString(), quote_identifier(), and str.

PLy_quote_literal()

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

static

Definition at line 294 of file plpy_plpymodule.c.

{
    const char *str;
    char       *quoted;
    PyObject   *ret;
 
    if (!PyArg_ParseTuple(args, "s:quote_literal", &str))
        return NULL;
 
    quoted = quote_literal_cstr(str);
    ret = PLyUnicode_FromString(quoted);
    pfree(quoted);
 
    return ret;
}

References fb(), pfree(), PLyUnicode_FromString(), quote_literal_cstr(), and str.

PLy_quote_nullable()

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

static

Definition at line 311 of file plpy_plpymodule.c.

{
    const char *str;
    char       *quoted;
    PyObject   *ret;
 
    if (!PyArg_ParseTuple(args, "z:quote_nullable", &str))
        return NULL;
 
    if (str == NULL)
        return PLyUnicode_FromString("NULL");
 
    quoted = quote_literal_cstr(str);
    ret = PLyUnicode_FromString(quoted);
    pfree(quoted);
 
    return ret;
}

References fb(), pfree(), PLyUnicode_FromString(), quote_literal_cstr(), and str.

PLy_warning()

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

static

Definition at line 276 of file plpy_plpymodule.c.

{
    return PLy_output(WARNING, self, args, kw);
}

References fb(), PLy_output(), and WARNING.

PyInit_plpy()

PyMODINIT_FUNC PyInit_plpy

(

void

)

Definition at line 126 of file plpy_plpymodule.c.

{
    PyObject   *m;
 
    m = PyModule_Create(&PLy_module);
    if (m == NULL)
        return NULL;
 
    PLy_add_exceptions(m);
 
    PLy_plan_init_type();
    PLy_result_init_type();
    PLy_subtransaction_init_type();
    PLy_cursor_init_type();
 
    return m;
}

References fb(), PLy_add_exceptions(), PLy_cursor_init_type(), PLy_module, PLy_plan_init_type(), PLy_result_init_type(), and PLy_subtransaction_init_type().

Referenced by _PG_init().

Variable Documentation

exception_map

const ExceptionMap exception_map[]

static

Initial value:

= {
 
    {NULL, NULL, 0}
}

Definition at line 50 of file plpy_plpymodule.c.

                                            {
#include "spiexceptions.h"
    {NULL, NULL, 0}
};

Referenced by PLy_generate_spi_exceptions().

PLy_exc_methods

PyMethodDef PLy_exc_methods[]

static

Initial value:

= {
    {NULL, NULL, 0, NULL}
}

Definition at line 103 of file plpy_plpymodule.c.

                                       {
    {NULL, NULL, 0, NULL}
};

PLy_exc_module

PyModuleDef PLy_exc_module

static

Initial value:

= {
    PyModuleDef_HEAD_INIT,
    .m_name = "spiexceptions",
    .m_size = -1,
    .m_methods = PLy_exc_methods,
}

Definition at line 114 of file plpy_plpymodule.c.

                                    {
    PyModuleDef_HEAD_INIT,
    .m_name = "spiexceptions",
    .m_size = -1,
    .m_methods = PLy_exc_methods,
};

Referenced by PLy_add_exceptions().

PLy_methods

PyMethodDef PLy_methods[]

static

Definition at line 55 of file plpy_plpymodule.c.

                                   {
    /*
     * logging methods
     */
    {"debug", (PyCFunction) (pg_funcptr_t) PLy_debug, METH_VARARGS | METH_KEYWORDS, NULL},
    {"log", (PyCFunction) (pg_funcptr_t) PLy_log, METH_VARARGS | METH_KEYWORDS, NULL},
    {"info", (PyCFunction) (pg_funcptr_t) PLy_info, METH_VARARGS | METH_KEYWORDS, NULL},
    {"notice", (PyCFunction) (pg_funcptr_t) PLy_notice, METH_VARARGS | METH_KEYWORDS, NULL},
    {"warning", (PyCFunction) (pg_funcptr_t) PLy_warning, METH_VARARGS | METH_KEYWORDS, NULL},
    {"error", (PyCFunction) (pg_funcptr_t) PLy_error, METH_VARARGS | METH_KEYWORDS, NULL},
    {"fatal", (PyCFunction) (pg_funcptr_t) PLy_fatal, METH_VARARGS | METH_KEYWORDS, NULL},
 
    /*
     * create a stored plan
     */
    {"prepare", PLy_spi_prepare, METH_VARARGS, NULL},
 
    /*
     * execute a plan or query
     */
    {"execute", PLy_spi_execute, METH_VARARGS, NULL},
 
    /*
     * escaping strings
     */
    {"quote_literal", PLy_quote_literal, METH_VARARGS, NULL},
    {"quote_nullable", PLy_quote_nullable, METH_VARARGS, NULL},
    {"quote_ident", PLy_quote_ident, METH_VARARGS, NULL},
 
    /*
     * create the subtransaction context manager
     */
    {"subtransaction", PLy_subtransaction_new, METH_NOARGS, NULL},
 
    /*
     * create a cursor
     */
    {"cursor", PLy_cursor, METH_VARARGS, NULL},
 
    /*
     * transaction control
     */
    {"commit", PLy_commit, METH_NOARGS, NULL},
    {"rollback", PLy_rollback, METH_NOARGS, NULL},
 
    {NULL, NULL, 0, NULL}
};

PLy_module

PyModuleDef PLy_module

static

Initial value:

= {
    PyModuleDef_HEAD_INIT,
    .m_name = "plpy",
    .m_size = -1,
    .m_methods = PLy_methods,
}

Definition at line 107 of file plpy_plpymodule.c.

                                {
    PyModuleDef_HEAD_INIT,
    .m_name = "plpy",
    .m_size = -1,
    .m_methods = PLy_methods,
};

Referenced by PyInit_plpy().

PLy_spi_exceptions

HTAB* PLy_spi_exceptions = NULL

Definition at line 20 of file plpy_plpymodule.c.

Referenced by PLy_add_exceptions(), PLy_commit(), PLy_generate_spi_exceptions(), PLy_rollback(), and PLy_spi_subtransaction_abort().