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
PGDLLEXPORT PyObject *	PLy_input_convert (PLyDatumToOb *arg, Datum val)
PGDLLEXPORT Datum	PLy_output_convert (PLyObToDatum *arg, PyObject *val, bool *isnull)
PGDLLEXPORT PyObject *	PLy_input_from_tuple (PLyDatumToOb *arg, HeapTuple tuple, TupleDesc desc, bool include_generated)
PGDLLEXPORT void	PLy_input_setup_func (PLyDatumToOb *arg, MemoryContext arg_mcxt, Oid typeOid, int32 typmod, struct PLyProcedure *proc)
PGDLLEXPORT void	PLy_output_setup_func (PLyObToDatum *arg, MemoryContext arg_mcxt, Oid typeOid, int32 typmod, struct PLyProcedure *proc)
PGDLLEXPORT void	PLy_input_setup_tuple (PLyDatumToOb *arg, TupleDesc desc, struct PLyProcedure *proc)
PGDLLEXPORT void	PLy_output_setup_tuple (PLyObToDatum *arg, TupleDesc desc, struct PLyProcedure *proc)
PGDLLEXPORT void	PLy_output_setup_record (PLyObToDatum *arg, TupleDesc desc, struct PLyProcedure *proc)
PGDLLEXPORT 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()

PGDLLEXPORT PyObject * PLy_input_convert	(	PLyDatumToOb *	arg,
		Datum	val
	)

Definition at line 81 of file plpy_typeio.c.

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

References arg, MemoryContextReset(), MemoryContextSwitchTo(), PLy_current_execution_context(), PLy_get_scratch_context(), and val.

Referenced by PLy_function_build_args().

PLy_input_from_tuple()

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

Definition at line 134 of file plpy_typeio.c.

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

References arg, 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().

PLy_input_setup_func()

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

Definition at line 418 of file plpy_typeio.c.

{
    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 = TYPALIGN_DOUBLE;
    }
 
    /*
     * 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 &&
             IsTrueArrayType(typentry))
    {
        /* Standard array */
        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 = PLyLong_FromInt16;
                break;
            case INT4OID:
                arg->func = PLyLong_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 = PLyUnicode_FromScalar;
                getTypeOutputInfo(typeOid, &typoutput, &typisvarlena);
                fmgr_info_cxt(typoutput, &arg->u.scalar.typfunc, arg_mcxt);
                break;
        }
    }
}

References arg, check_stack_depth(), TypeCacheEntry::domainBaseType, TypeCacheEntry::domainBaseTypmod, fmgr_info_cxt(), get_transform_fromsql(), getTypeOutputInfo(), INVALID_TUPLEDESC_IDENTIFIER, PLyProcedure::langid, lookup_type_cache(), MemoryContextAllocZero(), PLy_input_setup_func(), PLyBool_FromBool(), PLyBytes_FromBytea(), PLyDecimal_FromNumeric(), PLyDict_FromComposite(), PLyFloat_FromFloat4(), PLyFloat_FromFloat8(), PLyList_FromArray(), PLyLong_FromInt16(), PLyLong_FromInt32(), PLyLong_FromInt64(), PLyLong_FromOid(), PLyObject_FromTransform(), PLyUnicode_FromScalar(), PLyProcedure::trftypes, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TYPECACHE_DOMAIN_BASE_INFO, TypeCacheEntry::typelem, TypeCacheEntry::typlen, and TypeCacheEntry::typtype.

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().

PLy_input_setup_tuple()

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

Definition at line 165 of file plpy_typeio.c.

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

References arg, Assert(), i, MemoryContextAllocZero(), TupleDescData::natts, pfree(), PLy_input_setup_func(), PLyDict_FromComposite(), TupleDescAttr(), PLyDatumToOb::typmod, and PLyDatumToOb::typoid.

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

PLy_output_convert()

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

Definition at line 120 of file plpy_typeio.c.

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

References arg, and val.

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

PLy_output_setup_func()

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

Definition at line 296 of file plpy_typeio.c.

{
    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 = TYPALIGN_DOUBLE;
    }
 
    /*
     * 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 &&
             IsTrueArrayType(typentry))
    {
        /* Standard array */
        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;
        }
    }
}

References arg, check_stack_depth(), TypeCacheEntry::domainBaseType, TypeCacheEntry::domainBaseTypmod, fmgr_info_cxt(), get_transform_tosql(), getBaseType(), getTypeInputInfo(), INVALID_TUPLEDESC_IDENTIFIER, InvalidOid, PLyProcedure::langid, lookup_type_cache(), MemoryContextAllocZero(), PLy_output_setup_func(), PLyObject_ToBool(), PLyObject_ToBytea(), PLyObject_ToComposite(), PLyObject_ToDomain(), PLyObject_ToScalar(), PLyObject_ToTransform(), PLySequence_ToArray(), PLyProcedure::trftypes, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TYPECACHE_DOMAIN_BASE_INFO, TypeCacheEntry::typelem, TypeCacheEntry::typlen, and TypeCacheEntry::typtype.

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

PLy_output_setup_record()

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

Definition at line 261 of file plpy_typeio.c.

{
    /* 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);
}

References arg, Assert(), BlessTupleDesc(), PLy_output_setup_tuple(), TupleDescData::tdtypeid, and TupleDescData::tdtypmod.

Referenced by PLy_exec_function().

PLy_output_setup_tuple()

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

Definition at line 215 of file plpy_typeio.c.

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

References arg, Assert(), i, MemoryContextAllocZero(), TupleDescData::natts, pfree(), PLy_output_setup_func(), PLyObject_ToComposite(), TupleDescAttr(), PLyObToDatum::typmod, and PLyObToDatum::typoid.

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

PLyObject_AsString()

PGDLLEXPORT char * PLyObject_AsString

(

PyObject *

plrv

)

Definition at line 1027 of file plpy_typeio.c.

{
    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 */
        PyObject   *s = PyObject_Repr(plrv);
 
        plrv_bo = PLyUnicode_Bytes(s);
        Py_XDECREF(s);
    }
    else
    {
        PyObject   *s = PyObject_Str(plrv);
 
        plrv_bo = PLyUnicode_Bytes(s);
        Py_XDECREF(s);
    }
    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;
}

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

Referenced by PLyObject_ToScalar(), and PLyUnicode_ToComposite().