plpy_typeio.h File Reference

#include "access/htup.h"
#include "fmgr.h"
#include "plpython.h"
#include "utils/typcache.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	PLyScalarToOb
struct	PLyArrayToOb
struct	PLyTupleToOb
struct	PLyTransformToOb
struct	PLyDatumToOb
struct	PLyObToScalar
struct	PLyObToArray
struct	PLyObToTuple
struct	PLyObToDomain
struct	PLyObToTransform
struct	PLyObToDatum

Typedefs
typedef struct PLyDatumToOb	PLyDatumToOb
typedef PyObject *(*	PLyDatumToObFunc) (PLyDatumToOb *arg, Datum val)
typedef struct PLyScalarToOb	PLyScalarToOb
typedef struct PLyArrayToOb	PLyArrayToOb
typedef struct PLyTupleToOb	PLyTupleToOb
typedef struct PLyTransformToOb	PLyTransformToOb
typedef struct PLyObToDatum	PLyObToDatum
typedef Datum(*	PLyObToDatumFunc) (PLyObToDatum *arg, PyObject *val, bool *isnull, bool inarray)
typedef struct PLyObToScalar	PLyObToScalar
typedef struct PLyObToArray	PLyObToArray
typedef struct PLyObToTuple	PLyObToTuple
typedef struct PLyObToDomain	PLyObToDomain
typedef struct PLyObToTransform	PLyObToTransform

Functions
PyObject *	PLy_input_convert (PLyDatumToOb *arg, Datum val)
Datum	PLy_output_convert (PLyObToDatum *arg, PyObject *val, bool *isnull)
PyObject *	PLy_input_from_tuple (PLyDatumToOb *arg, HeapTuple tuple, TupleDesc desc, bool include_generated)
void	PLy_input_setup_func (PLyDatumToOb *arg, MemoryContext arg_mcxt, Oid typeOid, int32 typmod, struct PLyProcedure *proc)
void	PLy_output_setup_func (PLyObToDatum *arg, MemoryContext arg_mcxt, Oid typeOid, int32 typmod, struct PLyProcedure *proc)
void	PLy_input_setup_tuple (PLyDatumToOb *arg, TupleDesc desc, struct PLyProcedure *proc)
void	PLy_output_setup_tuple (PLyObToDatum *arg, TupleDesc desc, struct PLyProcedure *proc)
void	PLy_output_setup_record (PLyObToDatum *arg, TupleDesc desc, struct PLyProcedure *proc)
char *	PLyObject_AsString (PyObject *plrv)

Typedef Documentation

PLyArrayToOb

typedef struct PLyArrayToOb PLyArrayToOb

PLyDatumToOb

typedef struct PLyDatumToOb PLyDatumToOb

Definition at line 26 of file plpy_typeio.h.

PLyDatumToObFunc

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

Definition at line 28 of file plpy_typeio.h.

PLyObToArray

typedef struct PLyObToArray PLyObToArray

PLyObToDatum

typedef struct PLyObToDatum PLyObToDatum

Definition at line 87 of file plpy_typeio.h.

PLyObToDatumFunc

typedef Datum(* PLyObToDatumFunc) (PLyObToDatum *arg, PyObject *val, bool *isnull, bool inarray)

Definition at line 89 of file plpy_typeio.h.

PLyObToDomain

typedef struct PLyObToDomain PLyObToDomain

PLyObToScalar

typedef struct PLyObToScalar PLyObToScalar

PLyObToTransform

typedef struct PLyObToTransform PLyObToTransform

PLyObToTuple

typedef struct PLyObToTuple PLyObToTuple

PLyScalarToOb

typedef struct PLyScalarToOb PLyScalarToOb

PLyTransformToOb

typedef struct PLyTransformToOb PLyTransformToOb

PLyTupleToOb

typedef struct PLyTupleToOb PLyTupleToOb

Function Documentation

PLy_input_convert()

PyObject* PLy_input_convert	(	PLyDatumToOb *	arg,
		Datum	val
	)

Definition at line 80 of file plpy_typeio.c.

References PLyDatumToOb::func, MemoryContextReset(), MemoryContextSwitchTo(), PLy_current_execution_context(), and PLy_get_scratch_context().

Referenced by PLy_function_build_args().

{
    PyObject   *result;
    PLyExecutionContext *exec_ctx = PLy_current_execution_context();
    MemoryContext scratch_context = PLy_get_scratch_context(exec_ctx);
    MemoryContext oldcontext;

    /*
     * Do the work in the scratch context to avoid leaking memory from the
     * datatype output function calls.  (The individual PLyDatumToObFunc
     * functions can't reset the scratch context, because they recurse and an
     * inner one might clobber data an outer one still needs.  So we do it
     * once at the outermost recursion level.)
     *
     * We reset the scratch context before, not after, each conversion cycle.
     * This way we aren't on the hook to release a Python refcount on the
     * result object in case MemoryContextReset throws an error.
     */
    MemoryContextReset(scratch_context);

    oldcontext = MemoryContextSwitchTo(scratch_context);

    result = arg->func(arg, val);

    MemoryContextSwitchTo(oldcontext);

    return result;
}

PLy_input_from_tuple()

PyObject* PLy_input_from_tuple	(	PLyDatumToOb *	arg,
		HeapTuple	tuple,
		TupleDesc	desc,
		bool	include_generated
	)

Definition at line 133 of file plpy_typeio.c.

References MemoryContextReset(), MemoryContextSwitchTo(), PLy_current_execution_context(), PLy_get_scratch_context(), and PLyDict_FromTuple().

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

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

    /*
     * As in PLy_input_convert, do the work in the scratch context.
     */
    MemoryContextReset(scratch_context);

    oldcontext = MemoryContextSwitchTo(scratch_context);

    dict = PLyDict_FromTuple(arg, tuple, desc, include_generated);

    MemoryContextSwitchTo(oldcontext);

    return dict;
}

PLy_input_setup_func()

void PLy_input_setup_func	(	PLyDatumToOb *	arg,
		MemoryContext	arg_mcxt,
		Oid	typeOid,
		int32	typmod,
		struct PLyProcedure *	proc
	)

Definition at line 417 of file plpy_typeio.c.

References PLyDatumToOb::array, PLyTupleToOb::atts, check_stack_depth(), TypeCacheEntry::domainBaseType, TypeCacheEntry::domainBaseTypmod, PLyArrayToOb::elm, fmgr_info_cxt(), PLyDatumToOb::func, get_transform_fromsql(), getTypeOutputInfo(), INVALID_TUPLEDESC_IDENTIFIER, PLyProcedure::langid, lookup_type_cache(), PLyDatumToOb::mcxt, MemoryContextAllocZero(), PLyTupleToOb::natts, OidIsValid, PLy_input_setup_func(), PLyBool_FromBool(), PLyBytes_FromBytea(), PLyDecimal_FromNumeric(), PLyDict_FromComposite(), PLyFloat_FromFloat4(), PLyFloat_FromFloat8(), PLyInt_FromInt16(), PLyInt_FromInt32(), PLyList_FromArray(), PLyLong_FromInt64(), PLyLong_FromOid(), PLyObject_FromTransform(), PLyString_FromScalar(), PLyTupleToOb::recdesc, PLyDatumToOb::scalar, PLyDatumToOb::transform, PLyProcedure::trftypes, PLyTupleToOb::tupdescid, PLyDatumToOb::tuple, TypeCacheEntry::typalign, PLyDatumToOb::typalign, TypeCacheEntry::typbyval, PLyDatumToOb::typbyval, TYPECACHE_DOMAIN_BASE_INFO, TypeCacheEntry::typelem, PLyTupleToOb::typentry, PLyScalarToOb::typfunc, TypeCacheEntry::typlen, PLyDatumToOb::typlen, PLyDatumToOb::typmod, PLyDatumToOb::typoid, PLyTransformToOb::typtransform, TypeCacheEntry::typtype, and PLyDatumToOb::u.

Referenced by PLy_cursor_plan(), PLy_cursor_query(), PLy_exec_trigger(), PLy_input_setup_func(), PLy_input_setup_tuple(), PLy_procedure_create(), and PLy_spi_execute_fetch_result().

{
    TypeCacheEntry *typentry;
    char        typtype;
    Oid         trfuncid;
    Oid         typoutput;
    bool        typisvarlena;

    /* Since this is recursive, it could theoretically be driven to overflow */
    check_stack_depth();

    arg->typoid = typeOid;
    arg->typmod = typmod;
    arg->mcxt = arg_mcxt;

    /*
     * Fetch typcache entry for the target type, asking for whatever info
     * we'll need later.  RECORD is a special case: just treat it as composite
     * without bothering with the typcache entry.
     */
    if (typeOid != RECORDOID)
    {
        typentry = lookup_type_cache(typeOid, TYPECACHE_DOMAIN_BASE_INFO);
        typtype = typentry->typtype;
        arg->typbyval = typentry->typbyval;
        arg->typlen = typentry->typlen;
        arg->typalign = typentry->typalign;
    }
    else
    {
        typentry = NULL;
        typtype = TYPTYPE_COMPOSITE;
        /* hard-wired knowledge about type RECORD: */
        arg->typbyval = false;
        arg->typlen = -1;
        arg->typalign = 'd';
    }

    /*
     * Choose conversion method.  Note that transform functions are checked
     * for composite and scalar types, but not for arrays or domains.  This is
     * somewhat historical, but we'd have a problem allowing them on domains,
     * since we drill down through all levels of a domain nest without looking
     * at the intermediate levels at all.
     */
    if (typtype == TYPTYPE_DOMAIN)
    {
        /* Domain --- we don't care, just recurse down to the base type */
        PLy_input_setup_func(arg, arg_mcxt,
                             typentry->domainBaseType,
                             typentry->domainBaseTypmod,
                             proc);
    }
    else if (typentry &&
             OidIsValid(typentry->typelem) && typentry->typlen == -1)
    {
        /* Standard varlena array (cf. get_element_type) */
        arg->func = PLyList_FromArray;
        /* Recursively set up conversion info for the element type */
        arg->u.array.elm = (PLyDatumToOb *)
            MemoryContextAllocZero(arg_mcxt, sizeof(PLyDatumToOb));
        PLy_input_setup_func(arg->u.array.elm, arg_mcxt,
                             typentry->typelem, typmod,
                             proc);
    }
    else if ((trfuncid = get_transform_fromsql(typeOid,
                                               proc->langid,
                                               proc->trftypes)))
    {
        arg->func = PLyObject_FromTransform;
        fmgr_info_cxt(trfuncid, &arg->u.transform.typtransform, arg_mcxt);
    }
    else if (typtype == TYPTYPE_COMPOSITE)
    {
        /* Named composite type, or RECORD */
        arg->func = PLyDict_FromComposite;
        /* We'll set up the per-field data later */
        arg->u.tuple.recdesc = NULL;
        arg->u.tuple.typentry = typentry;
        arg->u.tuple.tupdescid = INVALID_TUPLEDESC_IDENTIFIER;
        arg->u.tuple.atts = NULL;
        arg->u.tuple.natts = 0;
    }
    else
    {
        /* Scalar type, but we have a couple of special cases */
        switch (typeOid)
        {
            case BOOLOID:
                arg->func = PLyBool_FromBool;
                break;
            case FLOAT4OID:
                arg->func = PLyFloat_FromFloat4;
                break;
            case FLOAT8OID:
                arg->func = PLyFloat_FromFloat8;
                break;
            case NUMERICOID:
                arg->func = PLyDecimal_FromNumeric;
                break;
            case INT2OID:
                arg->func = PLyInt_FromInt16;
                break;
            case INT4OID:
                arg->func = PLyInt_FromInt32;
                break;
            case INT8OID:
                arg->func = PLyLong_FromInt64;
                break;
            case OIDOID:
                arg->func = PLyLong_FromOid;
                break;
            case BYTEAOID:
                arg->func = PLyBytes_FromBytea;
                break;
            default:
                arg->func = PLyString_FromScalar;
                getTypeOutputInfo(typeOid, &typoutput, &typisvarlena);
                fmgr_info_cxt(typoutput, &arg->u.scalar.typfunc, arg_mcxt);
                break;
        }
    }
}

PLy_input_setup_tuple()

void PLy_input_setup_tuple	(	PLyDatumToOb *	arg,
		TupleDesc	desc,
		struct PLyProcedure *	proc
	)

Definition at line 164 of file plpy_typeio.c.

References Assert, PLyTupleToOb::atts, PLyDatumToOb::func, i, PLyDatumToOb::mcxt, MemoryContextAllocZero(), PLyTupleToOb::natts, TupleDescData::natts, pfree(), PLy_input_setup_func(), PLyDict_FromComposite(), PLyTupleToOb::recdesc, PLyDatumToOb::tuple, TupleDescAttr, PLyDatumToOb::typmod, PLyDatumToOb::typoid, and PLyDatumToOb::u.

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

{
    int         i;

    /* We should be working on a previously-set-up struct */
    Assert(arg->func == PLyDict_FromComposite);

    /* Save pointer to tupdesc, but only if this is an anonymous record type */
    if (arg->typoid == RECORDOID && arg->typmod < 0)
        arg->u.tuple.recdesc = desc;

    /* (Re)allocate atts array as needed */
    if (arg->u.tuple.natts != desc->natts)
    {
        if (arg->u.tuple.atts)
            pfree(arg->u.tuple.atts);
        arg->u.tuple.natts = desc->natts;
        arg->u.tuple.atts = (PLyDatumToOb *)
            MemoryContextAllocZero(arg->mcxt,
                                   desc->natts * sizeof(PLyDatumToOb));
    }

    /* Fill the atts entries, except for dropped columns */
    for (i = 0; i < desc->natts; i++)
    {
        Form_pg_attribute attr = TupleDescAttr(desc, i);
        PLyDatumToOb *att = &arg->u.tuple.atts[i];

        if (attr->attisdropped)
            continue;

        if (att->typoid == attr->atttypid && att->typmod == attr->atttypmod)
            continue;           /* already set up this entry */

        PLy_input_setup_func(att, arg->mcxt,
                             attr->atttypid, attr->atttypmod,
                             proc);
    }
}

PLy_output_convert()

Datum PLy_output_convert	(	PLyObToDatum *	arg,
		PyObject *	val,
		bool *	isnull
	)

Definition at line 119 of file plpy_typeio.c.

References PLyObToDatum::func.

Referenced by PLy_cursor_plan(), PLy_exec_function(), PLy_modify_tuple(), and PLy_spi_execute_plan().

{
    /* at outer level, we are not considering an array element */
    return arg->func(arg, val, isnull, false);
}

PLy_output_setup_func()

void PLy_output_setup_func	(	PLyObToDatum *	arg,
		MemoryContext	arg_mcxt,
		Oid	typeOid,
		int32	typmod,
		struct PLyProcedure *	proc
	)

Definition at line 295 of file plpy_typeio.c.

References PLyObToDatum::array, PLyObToTuple::atts, PLyObToDomain::base, check_stack_depth(), PLyObToDatum::domain, PLyObToDomain::domain_info, TypeCacheEntry::domainBaseType, TypeCacheEntry::domainBaseTypmod, PLyObToArray::elm, PLyObToArray::elmbasetype, fmgr_info_cxt(), FmgrInfo::fn_oid, PLyObToDatum::func, get_transform_tosql(), getBaseType(), getTypeInputInfo(), INVALID_TUPLEDESC_IDENTIFIER, InvalidOid, PLyProcedure::langid, lookup_type_cache(), PLyObToDatum::mcxt, MemoryContextAllocZero(), PLyObToTuple::natts, OidIsValid, PLy_output_setup_func(), PLyObject_ToBool(), PLyObject_ToBytea(), PLyObject_ToComposite(), PLyObject_ToDomain(), PLyObject_ToScalar(), PLyObject_ToTransform(), PLySequence_ToArray(), PLyObToTuple::recdesc, PLyObToTuple::recinfunc, PLyObToDatum::scalar, PLyObToDatum::transform, PLyProcedure::trftypes, PLyObToTuple::tupdescid, PLyObToDatum::tuple, TypeCacheEntry::typalign, PLyObToDatum::typalign, TypeCacheEntry::typbyval, PLyObToDatum::typbyval, TYPECACHE_DOMAIN_BASE_INFO, TypeCacheEntry::typelem, PLyObToTuple::typentry, PLyObToScalar::typfunc, PLyObToScalar::typioparam, TypeCacheEntry::typlen, PLyObToDatum::typlen, PLyObToDatum::typmod, PLyObToDatum::typoid, PLyObToTransform::typtransform, TypeCacheEntry::typtype, and PLyObToDatum::u.

Referenced by PLy_exec_trigger(), PLy_output_setup_func(), PLy_output_setup_tuple(), PLy_procedure_create(), and PLy_spi_prepare().

{
    TypeCacheEntry *typentry;
    char        typtype;
    Oid         trfuncid;
    Oid         typinput;

    /* Since this is recursive, it could theoretically be driven to overflow */
    check_stack_depth();

    arg->typoid = typeOid;
    arg->typmod = typmod;
    arg->mcxt = arg_mcxt;

    /*
     * Fetch typcache entry for the target type, asking for whatever info
     * we'll need later.  RECORD is a special case: just treat it as composite
     * without bothering with the typcache entry.
     */
    if (typeOid != RECORDOID)
    {
        typentry = lookup_type_cache(typeOid, TYPECACHE_DOMAIN_BASE_INFO);
        typtype = typentry->typtype;
        arg->typbyval = typentry->typbyval;
        arg->typlen = typentry->typlen;
        arg->typalign = typentry->typalign;
    }
    else
    {
        typentry = NULL;
        typtype = TYPTYPE_COMPOSITE;
        /* hard-wired knowledge about type RECORD: */
        arg->typbyval = false;
        arg->typlen = -1;
        arg->typalign = 'd';
    }

    /*
     * Choose conversion method.  Note that transform functions are checked
     * for composite and scalar types, but not for arrays or domains.  This is
     * somewhat historical, but we'd have a problem allowing them on domains,
     * since we drill down through all levels of a domain nest without looking
     * at the intermediate levels at all.
     */
    if (typtype == TYPTYPE_DOMAIN)
    {
        /* Domain */
        arg->func = PLyObject_ToDomain;
        arg->u.domain.domain_info = NULL;
        /* Recursively set up conversion info for the element type */
        arg->u.domain.base = (PLyObToDatum *)
            MemoryContextAllocZero(arg_mcxt, sizeof(PLyObToDatum));
        PLy_output_setup_func(arg->u.domain.base, arg_mcxt,
                              typentry->domainBaseType,
                              typentry->domainBaseTypmod,
                              proc);
    }
    else if (typentry &&
             OidIsValid(typentry->typelem) && typentry->typlen == -1)
    {
        /* Standard varlena array (cf. get_element_type) */
        arg->func = PLySequence_ToArray;
        /* Get base type OID to insert into constructed array */
        /* (note this might not be the same as the immediate child type) */
        arg->u.array.elmbasetype = getBaseType(typentry->typelem);
        /* Recursively set up conversion info for the element type */
        arg->u.array.elm = (PLyObToDatum *)
            MemoryContextAllocZero(arg_mcxt, sizeof(PLyObToDatum));
        PLy_output_setup_func(arg->u.array.elm, arg_mcxt,
                              typentry->typelem, typmod,
                              proc);
    }
    else if ((trfuncid = get_transform_tosql(typeOid,
                                             proc->langid,
                                             proc->trftypes)))
    {
        arg->func = PLyObject_ToTransform;
        fmgr_info_cxt(trfuncid, &arg->u.transform.typtransform, arg_mcxt);
    }
    else if (typtype == TYPTYPE_COMPOSITE)
    {
        /* Named composite type, or RECORD */
        arg->func = PLyObject_ToComposite;
        /* We'll set up the per-field data later */
        arg->u.tuple.recdesc = NULL;
        arg->u.tuple.typentry = typentry;
        arg->u.tuple.tupdescid = INVALID_TUPLEDESC_IDENTIFIER;
        arg->u.tuple.atts = NULL;
        arg->u.tuple.natts = 0;
        /* Mark this invalid till needed, too */
        arg->u.tuple.recinfunc.fn_oid = InvalidOid;
    }
    else
    {
        /* Scalar type, but we have a couple of special cases */
        switch (typeOid)
        {
            case BOOLOID:
                arg->func = PLyObject_ToBool;
                break;
            case BYTEAOID:
                arg->func = PLyObject_ToBytea;
                break;
            default:
                arg->func = PLyObject_ToScalar;
                getTypeInputInfo(typeOid, &typinput, &arg->u.scalar.typioparam);
                fmgr_info_cxt(typinput, &arg->u.scalar.typfunc, arg_mcxt);
                break;
        }
    }
}

PLy_output_setup_record()

void PLy_output_setup_record	(	PLyObToDatum *	arg,
		TupleDesc	desc,
		struct PLyProcedure *	proc
	)

Definition at line 260 of file plpy_typeio.c.

References Assert, BlessTupleDesc(), PLy_output_setup_tuple(), PLyObToTuple::recdesc, TupleDescData::tdtypeid, TupleDescData::tdtypmod, PLyObToDatum::tuple, PLyObToDatum::typmod, PLyObToDatum::typoid, and PLyObToDatum::u.

Referenced by PLy_function_build_args().

{
    /* Makes no sense unless RECORD */
    Assert(arg->typoid == RECORDOID);
    Assert(desc->tdtypeid == RECORDOID);

    /*
     * Bless the record type if not already done.  We'd have to do this anyway
     * to return a tuple, so we might as well force the issue so we can use
     * the known-record-type code path.
     */
    BlessTupleDesc(desc);

    /*
     * Update arg->typmod, and clear the recdesc link if it's changed. The
     * next call of PLyObject_ToComposite will look up a long-lived tupdesc
     * for the record type.
     */
    arg->typmod = desc->tdtypmod;
    if (arg->u.tuple.recdesc &&
        arg->u.tuple.recdesc->tdtypmod != arg->typmod)
        arg->u.tuple.recdesc = NULL;

    /* Update derived data if necessary */
    PLy_output_setup_tuple(arg, desc, proc);
}

PLy_output_setup_tuple()

void PLy_output_setup_tuple	(	PLyObToDatum *	arg,
		TupleDesc	desc,
		struct PLyProcedure *	proc
	)

Definition at line 214 of file plpy_typeio.c.

References Assert, PLyObToTuple::atts, PLyObToDatum::func, i, PLyObToDatum::mcxt, MemoryContextAllocZero(), TupleDescData::natts, PLyObToTuple::natts, pfree(), PLy_output_setup_func(), PLyObject_ToComposite(), PLyObToTuple::recdesc, PLyObToDatum::tuple, TupleDescAttr, PLyObToDatum::typmod, PLyObToDatum::typoid, and PLyObToDatum::u.

Referenced by PLy_exec_trigger(), PLy_output_setup_record(), and PLyObject_ToComposite().

{
    int         i;

    /* We should be working on a previously-set-up struct */
    Assert(arg->func == PLyObject_ToComposite);

    /* Save pointer to tupdesc, but only if this is an anonymous record type */
    if (arg->typoid == RECORDOID && arg->typmod < 0)
        arg->u.tuple.recdesc = desc;

    /* (Re)allocate atts array as needed */
    if (arg->u.tuple.natts != desc->natts)
    {
        if (arg->u.tuple.atts)
            pfree(arg->u.tuple.atts);
        arg->u.tuple.natts = desc->natts;
        arg->u.tuple.atts = (PLyObToDatum *)
            MemoryContextAllocZero(arg->mcxt,
                                   desc->natts * sizeof(PLyObToDatum));
    }

    /* Fill the atts entries, except for dropped columns */
    for (i = 0; i < desc->natts; i++)
    {
        Form_pg_attribute attr = TupleDescAttr(desc, i);
        PLyObToDatum *att = &arg->u.tuple.atts[i];

        if (attr->attisdropped)
            continue;

        if (att->typoid == attr->atttypid && att->typmod == attr->atttypmod)
            continue;           /* already set up this entry */

        PLy_output_setup_func(att, arg->mcxt,
                              attr->atttypid, attr->atttypmod,
                              proc);
    }
}

PLyObject_AsString()

char* PLyObject_AsString

(

PyObject *

plrv

)

Definition at line 1023 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_ToScalar(), and PLyString_ToComposite().

{
    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;
}