plpy_typeio.h File Reference

#include "access/htup.h"
#include "access/tupdesc.h"
#include "fmgr.h"
#include "storage/itemptr.h"

Include dependency graph for plpy_typeio.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PLyDatumToOb
struct	PLyTupleToOb
union	PLyTypeInput
struct	PLyObToDatum
struct	PLyObToTuple
union	PLyTypeOutput
struct	PLyTypeInfo

Typedefs
typedef PyObject *(*	PLyDatumToObFunc )(struct PLyDatumToOb *arg, Datum val)
typedef struct PLyDatumToOb	PLyDatumToOb
typedef struct PLyTupleToOb	PLyTupleToOb
typedef union PLyTypeInput	PLyTypeInput
typedef Datum(*	PLyObToDatumFunc )(struct PLyObToDatum *arg, int32 typmod, PyObject *val, bool inarray)
typedef struct PLyObToDatum	PLyObToDatum
typedef struct PLyObToTuple	PLyObToTuple
typedef union PLyTypeOutput	PLyTypeOutput
typedef struct PLyTypeInfo	PLyTypeInfo

Functions
void	PLy_typeinfo_init (PLyTypeInfo *arg, MemoryContext mcxt)
void	PLy_input_datum_func (PLyTypeInfo *arg, Oid typeOid, HeapTuple typeTup, Oid langid, List *trftypes)
void	PLy_output_datum_func (PLyTypeInfo *arg, HeapTuple typeTup, Oid langid, List *trftypes)
void	PLy_input_tuple_funcs (PLyTypeInfo *arg, TupleDesc desc)
void	PLy_output_tuple_funcs (PLyTypeInfo *arg, TupleDesc desc)
void	PLy_output_record_funcs (PLyTypeInfo *arg, TupleDesc desc)
Datum	PLyObject_ToCompositeDatum (PLyTypeInfo *info, TupleDesc desc, PyObject *plrv, bool isarray)
PyObject *	PLyDict_FromTuple (PLyTypeInfo *info, HeapTuple tuple, TupleDesc desc)
char *	PLyObject_AsString (PyObject *plrv)

Typedef Documentation

typedef struct PLyDatumToOb PLyDatumToOb

typedef PyObject*(* PLyDatumToObFunc)(struct PLyDatumToOb *arg, Datum val)

Definition at line 17 of file plpy_typeio.h.

typedef struct PLyObToDatum PLyObToDatum

typedef Datum(* PLyObToDatumFunc)(struct PLyObToDatum *arg, int32 typmod, PyObject *val, bool inarray)

Definition at line 53 of file plpy_typeio.h.

typedef struct PLyObToTuple PLyObToTuple

typedef struct PLyTupleToOb PLyTupleToOb

typedef struct PLyTypeInfo PLyTypeInfo

typedef union PLyTypeInput PLyTypeInput

typedef union PLyTypeOutput PLyTypeOutput

Function Documentation

void PLy_input_datum_func	(	PLyTypeInfo *	arg,
		Oid	typeOid,
		HeapTuple	typeTup,
		Oid	langid,
		List *	trftypes
	)

Definition at line 87 of file plpy_typeio.c.

References PLyTypeInput::d, elog, ERROR, PLyTypeInfo::in, PLyTypeInfo::is_rowtype, PLyTypeInfo::mcxt, and PLy_input_datum_func2().

Referenced by PLy_procedure_create().

{
    if (arg->is_rowtype > 0)
        elog(ERROR, "PLyTypeInfo struct is initialized for Tuple");
    arg->is_rowtype = 0;
    PLy_input_datum_func2(&(arg->in.d), arg->mcxt, typeOid, typeTup, langid, trftypes);
}

void PLy_input_tuple_funcs	(	PLyTypeInfo *	arg,
		TupleDesc	desc
	)

Definition at line 105 of file plpy_typeio.c.

References Assert, PLyTupleToOb::atts, PLyExecutionContext::curr_proc, elog, ERROR, HeapTupleHeaderGetRawXmin, HeapTupleIsValid, i, PLyTypeInfo::in, PLyTypeInfo::is_rowtype, PLyProcedure::langid, PLyTypeInfo::mcxt, MemoryContextSwitchTo(), PLyTupleToOb::natts, tupleDesc::natts, ObjectIdGetDatum, OidIsValid, palloc0(), pfree(), PLy_current_execution_context(), PLy_input_datum_func2(), PLyTypeInput::r, RECORDOID, ReleaseSysCache(), RELOID, SearchSysCache1, HeapTupleData::t_data, HeapTupleData::t_self, tupleDesc::tdtypeid, tupleDesc::tdtypmod, PLyProcedure::trftypes, TupleDescAttr, PLyTypeInfo::typ_relid, typeidTypeRelid(), TYPEOID, PLyDatumToOb::typoid, PLyTypeInfo::typrel_tid, and PLyTypeInfo::typrel_xmin.

Referenced by PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_exec_trigger(), PLy_function_build_args(), and PLy_spi_execute_fetch_result().

{
    int         i;
    PLyExecutionContext *exec_ctx = PLy_current_execution_context();
    MemoryContext oldcxt;

    oldcxt = MemoryContextSwitchTo(arg->mcxt);

    if (arg->is_rowtype == 0)
        elog(ERROR, "PLyTypeInfo struct is initialized for a Datum");
    arg->is_rowtype = 1;

    if (arg->in.r.natts != desc->natts)
    {
        if (arg->in.r.atts)
            pfree(arg->in.r.atts);
        arg->in.r.natts = desc->natts;
        arg->in.r.atts = palloc0(desc->natts * sizeof(PLyDatumToOb));
    }

    /* Can this be an unnamed tuple? If not, then an Assert would be enough */
    if (desc->tdtypmod != -1)
        elog(ERROR, "received unnamed record type as input");

    Assert(OidIsValid(desc->tdtypeid));

    /*
     * RECORDOID means we got called to create input functions for a tuple
     * fetched by plpy.execute or for an anonymous record type
     */
    if (desc->tdtypeid != RECORDOID)
    {
        HeapTuple   relTup;

        /* Get the pg_class tuple corresponding to the type of the input */
        arg->typ_relid = typeidTypeRelid(desc->tdtypeid);
        relTup = SearchSysCache1(RELOID, ObjectIdGetDatum(arg->typ_relid));
        if (!HeapTupleIsValid(relTup))
            elog(ERROR, "cache lookup failed for relation %u", arg->typ_relid);

        /* Remember XMIN and TID for later validation if cache is still OK */
        arg->typrel_xmin = HeapTupleHeaderGetRawXmin(relTup->t_data);
        arg->typrel_tid = relTup->t_self;

        ReleaseSysCache(relTup);
    }

    for (i = 0; i < desc->natts; i++)
    {
        HeapTuple   typeTup;
        Form_pg_attribute attr = TupleDescAttr(desc, i);

        if (attr->attisdropped)
            continue;

        if (arg->in.r.atts[i].typoid == attr->atttypid)
            continue;           /* already set up this entry */

        typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(attr->atttypid));
        if (!HeapTupleIsValid(typeTup))
            elog(ERROR, "cache lookup failed for type %u",
                 attr->atttypid);

        PLy_input_datum_func2(&(arg->in.r.atts[i]), arg->mcxt,
                              attr->atttypid,
                              typeTup,
                              exec_ctx->curr_proc->langid,
                              exec_ctx->curr_proc->trftypes);

        ReleaseSysCache(typeTup);
    }

    MemoryContextSwitchTo(oldcxt);
}

void PLy_output_datum_func	(	PLyTypeInfo *	arg,
		HeapTuple	typeTup,
		Oid	langid,
		List *	trftypes
	)

Definition at line 96 of file plpy_typeio.c.

References PLyTypeOutput::d, elog, ERROR, PLyTypeInfo::is_rowtype, PLyTypeInfo::mcxt, PLyTypeInfo::out, and PLy_output_datum_func2().

Referenced by PLy_procedure_create(), and PLy_spi_prepare().

{
    if (arg->is_rowtype > 0)
        elog(ERROR, "PLyTypeInfo struct is initialized for a Tuple");
    arg->is_rowtype = 0;
    PLy_output_datum_func2(&(arg->out.d), arg->mcxt, typeTup, langid, trftypes);
}

void PLy_output_record_funcs	(	PLyTypeInfo *	arg,
		TupleDesc	desc
	)

Definition at line 251 of file plpy_typeio.c.

References Assert, BlessTupleDesc(), PLyTypeOutput::d, PLyTypeInfo::is_rowtype, PLyTypeInfo::out, PLy_output_tuple_funcs(), tupleDesc::tdtypmod, and PLyObToDatum::typmod.

Referenced by PLy_function_build_args().

{
    /*
     * If the output record functions are already set, we just have to check
     * if the record descriptor has not changed
     */
    if ((arg->is_rowtype == 1) &&
        (arg->out.d.typmod != -1) &&
        (arg->out.d.typmod == desc->tdtypmod))
        return;

    /* bless the record to make it known to the typcache lookup code */
    BlessTupleDesc(desc);
    /* save the freshly generated typmod */
    arg->out.d.typmod = desc->tdtypmod;
    /* proceed with normal I/O function caching */
    PLy_output_tuple_funcs(arg, desc);

    /*
     * it should change is_rowtype to 1, so we won't go through this again
     * unless the output record description changes
     */
    Assert(arg->is_rowtype == 1);
}

void PLy_output_tuple_funcs	(	PLyTypeInfo *	arg,
		TupleDesc	desc
	)

Definition at line 181 of file plpy_typeio.c.

References Assert, PLyObToTuple::atts, PLyExecutionContext::curr_proc, elog, ERROR, HeapTupleHeaderGetRawXmin, HeapTupleIsValid, i, PLyTypeInfo::is_rowtype, PLyProcedure::langid, PLyTypeInfo::mcxt, MemoryContextSwitchTo(), PLyObToTuple::natts, tupleDesc::natts, ObjectIdGetDatum, OidIsValid, PLyTypeInfo::out, palloc0(), pfree(), PLy_current_execution_context(), PLy_output_datum_func2(), PLyTypeOutput::r, RECORDOID, ReleaseSysCache(), RELOID, SearchSysCache1, HeapTupleData::t_data, HeapTupleData::t_self, tupleDesc::tdtypeid, PLyProcedure::trftypes, TupleDescAttr, PLyTypeInfo::typ_relid, typeidTypeRelid(), TYPEOID, PLyObToDatum::typoid, PLyTypeInfo::typrel_tid, and PLyTypeInfo::typrel_xmin.

Referenced by PLy_exec_trigger(), PLy_output_record_funcs(), PLyGenericObject_ToComposite(), PLyMapping_ToComposite(), and PLySequence_ToComposite().

{
    int         i;
    PLyExecutionContext *exec_ctx = PLy_current_execution_context();
    MemoryContext oldcxt;

    oldcxt = MemoryContextSwitchTo(arg->mcxt);

    if (arg->is_rowtype == 0)
        elog(ERROR, "PLyTypeInfo struct is initialized for a Datum");
    arg->is_rowtype = 1;

    if (arg->out.r.natts != desc->natts)
    {
        if (arg->out.r.atts)
            pfree(arg->out.r.atts);
        arg->out.r.natts = desc->natts;
        arg->out.r.atts = palloc0(desc->natts * sizeof(PLyObToDatum));
    }

    Assert(OidIsValid(desc->tdtypeid));

    /*
     * RECORDOID means we got called to create output functions for an
     * anonymous record type
     */
    if (desc->tdtypeid != RECORDOID)
    {
        HeapTuple   relTup;

        /* Get the pg_class tuple corresponding to the type of the output */
        arg->typ_relid = typeidTypeRelid(desc->tdtypeid);
        relTup = SearchSysCache1(RELOID, ObjectIdGetDatum(arg->typ_relid));
        if (!HeapTupleIsValid(relTup))
            elog(ERROR, "cache lookup failed for relation %u", arg->typ_relid);

        /* Remember XMIN and TID for later validation if cache is still OK */
        arg->typrel_xmin = HeapTupleHeaderGetRawXmin(relTup->t_data);
        arg->typrel_tid = relTup->t_self;

        ReleaseSysCache(relTup);
    }

    for (i = 0; i < desc->natts; i++)
    {
        HeapTuple   typeTup;
        Form_pg_attribute attr = TupleDescAttr(desc, i);

        if (attr->attisdropped)
            continue;

        if (arg->out.r.atts[i].typoid == attr->atttypid)
            continue;           /* already set up this entry */

        typeTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(attr->atttypid));
        if (!HeapTupleIsValid(typeTup))
            elog(ERROR, "cache lookup failed for type %u",
                 attr->atttypid);

        PLy_output_datum_func2(&(arg->out.r.atts[i]), arg->mcxt, typeTup,
                               exec_ctx->curr_proc->langid,
                               exec_ctx->curr_proc->trftypes);

        ReleaseSysCache(typeTup);
    }

    MemoryContextSwitchTo(oldcxt);
}

void PLy_typeinfo_init	(	PLyTypeInfo *	arg,
		MemoryContext	mcxt
	)

Definition at line 70 of file plpy_typeio.c.

References PLyTupleToOb::atts, PLyObToTuple::atts, PLyTypeInfo::in, InvalidOid, InvalidTransactionId, PLyTypeInfo::is_rowtype, ItemPointerSetInvalid, PLyTypeInfo::mcxt, PLyTupleToOb::natts, PLyObToTuple::natts, PLyTypeInfo::out, PLyTypeInput::r, PLyTypeOutput::r, PLyTypeInfo::typ_relid, PLyTypeInfo::typrel_tid, and PLyTypeInfo::typrel_xmin.

Referenced by PLy_cursor_plan(), PLy_cursor_query(), PLy_procedure_create(), PLy_spi_execute_fetch_result(), PLy_spi_prepare(), PLyObject_ToComposite(), and PLyString_ToComposite().

{
    arg->is_rowtype = -1;
    arg->in.r.natts = arg->out.r.natts = 0;
    arg->in.r.atts = NULL;
    arg->out.r.atts = NULL;
    arg->typ_relid = InvalidOid;
    arg->typrel_xmin = InvalidTransactionId;
    ItemPointerSetInvalid(&arg->typrel_tid);
    arg->mcxt = mcxt;
}

PyObject* PLyDict_FromTuple	(	PLyTypeInfo *	info,
		HeapTuple	tuple,
		TupleDesc	desc
	)

Definition at line 280 of file plpy_typeio.c.

References PLyTupleToOb::atts, CurrentMemoryContext, elog, ERROR, PLyDatumToOb::func, heap_getattr, i, PLyTypeInfo::in, PLyTypeInfo::is_rowtype, MemoryContextReset(), MemoryContextSwitchTo(), NameStr, PLyTupleToOb::natts, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PLy_current_execution_context(), PLy_elog(), PLy_get_scratch_context(), PLyTypeInput::r, TupleDescAttr, and value.

Referenced by PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_function_build_args(), PLy_spi_execute_fetch_result(), and PLy_trigger_build_args().

{
    PyObject   *volatile dict;
    PLyExecutionContext *exec_ctx = PLy_current_execution_context();
    MemoryContext scratch_context = PLy_get_scratch_context(exec_ctx);
    MemoryContext oldcontext = CurrentMemoryContext;

    if (info->is_rowtype != 1)
        elog(ERROR, "PLyTypeInfo structure describes a datum");

    dict = PyDict_New();
    if (dict == NULL)
        PLy_elog(ERROR, "could not create new dictionary");

    PG_TRY();
    {
        int         i;

        /*
         * Do the work in the scratch context to avoid leaking memory from the
         * datatype output function calls.
         */
        MemoryContextSwitchTo(scratch_context);
        for (i = 0; i < info->in.r.natts; i++)
        {
            char       *key;
            Datum       vattr;
            bool        is_null;
            PyObject   *value;
            Form_pg_attribute attr = TupleDescAttr(desc, i);

            if (attr->attisdropped)
                continue;

            key = NameStr(attr->attname);
            vattr = heap_getattr(tuple, (i + 1), desc, &is_null);

            if (is_null || info->in.r.atts[i].func == NULL)
                PyDict_SetItemString(dict, key, Py_None);
            else
            {
                value = (info->in.r.atts[i].func) (&info->in.r.atts[i], vattr);
                PyDict_SetItemString(dict, key, value);
                Py_DECREF(value);
            }
        }
        MemoryContextSwitchTo(oldcontext);
        MemoryContextReset(scratch_context);
    }
    PG_CATCH();
    {
        MemoryContextSwitchTo(oldcontext);
        Py_DECREF(dict);
        PG_RE_THROW();
    }
    PG_END_TRY();

    return dict;
}

char* PLyObject_AsString

(

PyObject *

plrv

)

Definition at line 850 of file plpy_typeio.c.

References elog, ereport, errcode(), errmsg(), ERROR, pg_verifymbstr(), PLy_elog(), PLyUnicode_Bytes(), pstrdup(), PyBytes_AsString, and PyBytes_Size.

Referenced by PLyObject_ToDatum().

{
    PyObject   *plrv_bo;
    char       *plrv_sc;
    size_t      plen;
    size_t      slen;

    if (PyUnicode_Check(plrv))
        plrv_bo = PLyUnicode_Bytes(plrv);
    else if (PyFloat_Check(plrv))
    {
        /* use repr() for floats, str() is lossy */
#if PY_MAJOR_VERSION >= 3
        PyObject   *s = PyObject_Repr(plrv);

        plrv_bo = PLyUnicode_Bytes(s);
        Py_XDECREF(s);
#else
        plrv_bo = PyObject_Repr(plrv);
#endif
    }
    else
    {
#if PY_MAJOR_VERSION >= 3
        PyObject   *s = PyObject_Str(plrv);

        plrv_bo = PLyUnicode_Bytes(s);
        Py_XDECREF(s);
#else
        plrv_bo = PyObject_Str(plrv);
#endif
    }
    if (!plrv_bo)
        PLy_elog(ERROR, "could not create string representation of Python object");

    plrv_sc = pstrdup(PyBytes_AsString(plrv_bo));
    plen = PyBytes_Size(plrv_bo);
    slen = strlen(plrv_sc);

    Py_XDECREF(plrv_bo);

    if (slen < plen)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("could not convert Python object into cstring: Python string representation appears to contain null bytes")));
    else if (slen > plen)
        elog(ERROR, "could not convert Python object into cstring: Python string longer than reported length");
    pg_verifymbstr(plrv_sc, slen, false);

    return plrv_sc;
}

Datum PLyObject_ToCompositeDatum	(	PLyTypeInfo *	info,
		TupleDesc	desc,
		PyObject *	plrv,
		bool	isarray
	)

Definition at line 346 of file plpy_typeio.c.

References PLyGenericObject_ToComposite(), PLyMapping_ToComposite(), PLySequence_ToComposite(), and PLyString_ToComposite().

Referenced by PLy_exec_function(), and PLyObject_ToComposite().

{
    Datum       datum;

    if (PyString_Check(plrv) || PyUnicode_Check(plrv))
        datum = PLyString_ToComposite(info, desc, plrv, inarray);
    else if (PySequence_Check(plrv))
        /* composite type as sequence (tuple, list etc) */
        datum = PLySequence_ToComposite(info, desc, plrv);
    else if (PyMapping_Check(plrv))
        /* composite type as mapping (currently only dict) */
        datum = PLyMapping_ToComposite(info, desc, plrv);
    else
        /* returned as smth, must provide method __getattr__(name) */
        datum = PLyGenericObject_ToComposite(info, desc, plrv, inarray);

    return datum;
}