expandedrecord.h File Reference

#include "access/htup.h"
#include "access/tupdesc.h"
#include "fmgr.h"
#include "utils/expandeddatum.h"

Include dependency graph for expandedrecord.h:

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

Go to the source code of this file.

Data Structures
struct	ExpandedRecordHeader
struct	ExpandedRecordFieldInfo

Macros
#define	ER_MAGIC   1384727874 /* ID for debugging crosschecks */
#define	ER_FLAG_FVALUE_VALID   0x0001 /* fvalue is up to date? */
#define	ER_FLAG_FVALUE_ALLOCED   0x0002 /* fvalue is local storage? */
#define	ER_FLAG_DVALUES_VALID   0x0004 /* dvalues/dnulls are up to date? */
#define	ER_FLAG_DVALUES_ALLOCED   0x0008 /* any field values local storage? */
#define	ER_FLAG_HAVE_EXTERNAL   0x0010 /* any field values are external? */
#define	ER_FLAG_TUPDESC_ALLOCED   0x0020 /* tupdesc is local storage? */
#define	ER_FLAG_IS_DOMAIN   0x0040 /* er_decltypeid is domain? */
#define	ER_FLAG_IS_DUMMY   0x0080 /* this header is dummy (see below) */
#define	ER_FLAGS_NON_DATA    (ER_FLAG_TUPDESC_ALLOCED | ER_FLAG_IS_DOMAIN | ER_FLAG_IS_DUMMY)
#define	PG_GETARG_EXPANDED_RECORD(n)   DatumGetExpandedRecord(PG_GETARG_DATUM(n))
#define	PG_RETURN_EXPANDED_RECORD(x)   PG_RETURN_DATUM(ExpandedRecordGetDatum(x))
#define	ExpandedRecordIsEmpty(erh)    (((erh)->flags & (ER_FLAG_DVALUES_VALID | ER_FLAG_FVALUE_VALID)) == 0)
#define	ExpandedRecordIsDomain(erh)    (((erh)->flags & ER_FLAG_IS_DOMAIN) != 0)
#define	TransferExpandedRecord(erh, cxt)    MemoryContextSetParent((erh)->hdr.eoh_context, cxt)
#define	expanded_record_set_field(erh, fnumber, newValue, isnull, expand_external)    expanded_record_set_field_internal(erh, fnumber, newValue, isnull, expand_external, true)

Typedefs
typedef struct ExpandedRecordHeader	ExpandedRecordHeader
typedef struct ExpandedRecordFieldInfo	ExpandedRecordFieldInfo

Functions
static Datum	ExpandedRecordGetDatum (const ExpandedRecordHeader *erh)
static Datum	ExpandedRecordGetRODatum (const ExpandedRecordHeader *erh)
ExpandedRecordHeader *	make_expanded_record_from_typeid (Oid type_id, int32 typmod, MemoryContext parentcontext)
ExpandedRecordHeader *	make_expanded_record_from_tupdesc (TupleDesc tupdesc, MemoryContext parentcontext)
ExpandedRecordHeader *	make_expanded_record_from_exprecord (ExpandedRecordHeader *olderh, MemoryContext parentcontext)
void	expanded_record_set_tuple (ExpandedRecordHeader *erh, HeapTuple tuple, bool copy, bool expand_external)
Datum	make_expanded_record_from_datum (Datum recorddatum, MemoryContext parentcontext)
TupleDesc	expanded_record_fetch_tupdesc (ExpandedRecordHeader *erh)
HeapTuple	expanded_record_get_tuple (ExpandedRecordHeader *erh)
ExpandedRecordHeader *	DatumGetExpandedRecord (Datum d)
void	deconstruct_expanded_record (ExpandedRecordHeader *erh)
bool	expanded_record_lookup_field (ExpandedRecordHeader *erh, const char *fieldname, ExpandedRecordFieldInfo *finfo)
Datum	expanded_record_fetch_field (ExpandedRecordHeader *erh, int fnumber, bool *isnull)
void	expanded_record_set_field_internal (ExpandedRecordHeader *erh, int fnumber, Datum newValue, bool isnull, bool expand_external, bool check_constraints)
void	expanded_record_set_fields (ExpandedRecordHeader *erh, const Datum *newValues, const bool *isnulls, bool expand_external)
static TupleDesc	expanded_record_get_tupdesc (ExpandedRecordHeader *erh)
static Datum	expanded_record_get_field (ExpandedRecordHeader *erh, int fnumber, bool *isnull)

Macro Definition Documentation

ER_FLAG_DVALUES_ALLOCED

#define ER_FLAG_DVALUES_ALLOCED   0x0008 /* any field values local storage? */

Definition at line 55 of file expandedrecord.h.

ER_FLAG_DVALUES_VALID

#define ER_FLAG_DVALUES_VALID   0x0004 /* dvalues/dnulls are up to date? */

Definition at line 54 of file expandedrecord.h.

ER_FLAG_FVALUE_ALLOCED

#define ER_FLAG_FVALUE_ALLOCED   0x0002 /* fvalue is local storage? */

Definition at line 53 of file expandedrecord.h.

ER_FLAG_FVALUE_VALID

#define ER_FLAG_FVALUE_VALID   0x0001 /* fvalue is up to date? */

Definition at line 52 of file expandedrecord.h.

ER_FLAG_HAVE_EXTERNAL

#define ER_FLAG_HAVE_EXTERNAL   0x0010 /* any field values are external? */

Definition at line 56 of file expandedrecord.h.

ER_FLAG_IS_DOMAIN

#define ER_FLAG_IS_DOMAIN   0x0040 /* er_decltypeid is domain? */

Definition at line 58 of file expandedrecord.h.

ER_FLAG_IS_DUMMY

#define ER_FLAG_IS_DUMMY   0x0080 /* this header is dummy (see below) */

Definition at line 59 of file expandedrecord.h.

ER_FLAG_TUPDESC_ALLOCED

#define ER_FLAG_TUPDESC_ALLOCED   0x0020 /* tupdesc is local storage? */

Definition at line 57 of file expandedrecord.h.

ER_FLAGS_NON_DATA

#define ER_FLAGS_NON_DATA    (ER_FLAG_TUPDESC_ALLOCED | ER_FLAG_IS_DOMAIN | ER_FLAG_IS_DUMMY)

Definition at line 61 of file expandedrecord.h.

ER_MAGIC

#define ER_MAGIC   1384727874 /* ID for debugging crosschecks */

Definition at line 40 of file expandedrecord.h.

expanded_record_set_field

#define expanded_record_set_field	(		erh,
			fnumber,
			newValue,
			isnull,
			expand_external
	)		expanded_record_set_field_internal(erh, fnumber, newValue, isnull, expand_external, true)

Definition at line 208 of file expandedrecord.h.

ExpandedRecordIsDomain

#define ExpandedRecordIsDomain

(

erh

)

(((erh)->flags & ER_FLAG_IS_DOMAIN) != 0)

Definition at line 160 of file expandedrecord.h.

ExpandedRecordIsEmpty

#define ExpandedRecordIsEmpty

(

erh

)

(((erh)->flags & (ER_FLAG_DVALUES_VALID | ER_FLAG_FVALUE_VALID)) == 0)

Definition at line 158 of file expandedrecord.h.

PG_GETARG_EXPANDED_RECORD

#define PG_GETARG_EXPANDED_RECORD

(

n

)

DatumGetExpandedRecord(PG_GETARG_DATUM(n))

Definition at line 154 of file expandedrecord.h.

PG_RETURN_EXPANDED_RECORD

#define PG_RETURN_EXPANDED_RECORD

(

x

)

PG_RETURN_DATUM(ExpandedRecordGetDatum(x))

Definition at line 155 of file expandedrecord.h.

TransferExpandedRecord

#define TransferExpandedRecord	(		erh,
			cxt
	)		MemoryContextSetParent((erh)->hdr.eoh_context, cxt)

Definition at line 164 of file expandedrecord.h.

Typedef Documentation

ExpandedRecordFieldInfo

typedef struct ExpandedRecordFieldInfo ExpandedRecordFieldInfo

ExpandedRecordHeader

typedef struct ExpandedRecordHeader ExpandedRecordHeader

Function Documentation

DatumGetExpandedRecord()

ExpandedRecordHeader* DatumGetExpandedRecord

(

Datum

d

)

Definition at line 927 of file expandedrecord.c.

{
    /* If it's a writable expanded record already, just return it */
    if (VARATT_IS_EXTERNAL_EXPANDED_RW(DatumGetPointer(d)))
    {
        ExpandedRecordHeader *erh = (ExpandedRecordHeader *) DatumGetEOHP(d);
 
        Assert(erh->er_magic == ER_MAGIC);
        return erh;
    }
 
    /* Else expand the hard way */
    d = make_expanded_record_from_datum(d, CurrentMemoryContext);
    return (ExpandedRecordHeader *) DatumGetEOHP(d);
}

References Assert, CurrentMemoryContext, DatumGetEOHP(), DatumGetPointer(), ER_MAGIC, ExpandedRecordHeader::er_magic, make_expanded_record_from_datum(), and VARATT_IS_EXTERNAL_EXPANDED_RW.

deconstruct_expanded_record()

void deconstruct_expanded_record

(

ExpandedRecordHeader *

erh

)

Definition at line 952 of file expandedrecord.c.

{
    TupleDesc   tupdesc;
    Datum      *dvalues;
    bool       *dnulls;
    int         nfields;
 
    if (erh->flags & ER_FLAG_DVALUES_VALID)
        return;                 /* already valid, nothing to do */
 
    /* We'll need the tuple descriptor */
    tupdesc = expanded_record_get_tupdesc(erh);
 
    /*
     * Allocate arrays in private context, if we don't have them already.  We
     * don't expect to see a change in nfields here, so while we cope if it
     * happens, we don't bother avoiding a leak of the old arrays (which might
     * not be separately palloc'd, anyway).
     */
    nfields = tupdesc->natts;
    if (erh->dvalues == NULL || erh->nfields != nfields)
    {
        char       *chunk;
 
        /*
         * To save a palloc cycle, we allocate both the Datum and isnull
         * arrays in one palloc chunk.
         */
        chunk = MemoryContextAlloc(erh->hdr.eoh_context,
                                   nfields * (sizeof(Datum) + sizeof(bool)));
        dvalues = (Datum *) chunk;
        dnulls = (bool *) (chunk + nfields * sizeof(Datum));
        erh->dvalues = dvalues;
        erh->dnulls = dnulls;
        erh->nfields = nfields;
    }
    else
    {
        dvalues = erh->dvalues;
        dnulls = erh->dnulls;
    }
 
    if (erh->flags & ER_FLAG_FVALUE_VALID)
    {
        /* Deconstruct tuple */
        heap_deform_tuple(erh->fvalue, tupdesc, dvalues, dnulls);
    }
    else
    {
        /* If record was empty, instantiate it as a row of nulls */
        memset(dvalues, 0, nfields * sizeof(Datum));
        memset(dnulls, true, nfields * sizeof(bool));
    }
 
    /* Mark the dvalues as valid */
    erh->flags |= ER_FLAG_DVALUES_VALID;
}

References chunk, ExpandedRecordHeader::dnulls, ExpandedRecordHeader::dvalues, ExpandedObjectHeader::eoh_context, ER_FLAG_DVALUES_VALID, ER_FLAG_FVALUE_VALID, expanded_record_get_tupdesc(), ExpandedRecordHeader::flags, ExpandedRecordHeader::fvalue, ExpandedRecordHeader::hdr, heap_deform_tuple(), MemoryContextAlloc(), TupleDescData::natts, and ExpandedRecordHeader::nfields.

Referenced by check_domain_for_new_field(), ER_get_flat_size(), exec_move_row(), exec_move_row_from_datum(), exec_stmt_return_next(), expanded_record_fetch_field(), expanded_record_set_field_internal(), and expanded_record_set_fields().

expanded_record_fetch_field()

Datum expanded_record_fetch_field	(	ExpandedRecordHeader *	erh,
		int	fnumber,
		bool *	isnull
	)

Definition at line 1063 of file expandedrecord.c.

{
    if (fnumber > 0)
    {
        /* Empty record has null fields */
        if (ExpandedRecordIsEmpty(erh))
        {
            *isnull = true;
            return (Datum) 0;
        }
        /* Make sure we have deconstructed form */
        deconstruct_expanded_record(erh);
        /* Out-of-range field number reads as null */
        if (unlikely(fnumber > erh->nfields))
        {
            *isnull = true;
            return (Datum) 0;
        }
        *isnull = erh->dnulls[fnumber - 1];
        return erh->dvalues[fnumber - 1];
    }
    else
    {
        /* System columns read as null if we haven't got flat tuple */
        if (erh->fvalue == NULL)
        {
            *isnull = true;
            return (Datum) 0;
        }
        /* heap_getsysattr doesn't actually use tupdesc, so just pass null */
        return heap_getsysattr(erh->fvalue, fnumber, NULL, isnull);
    }
}

References deconstruct_expanded_record(), ExpandedRecordHeader::dnulls, ExpandedRecordHeader::dvalues, ExpandedRecordIsEmpty, ExpandedRecordHeader::fvalue, heap_getsysattr(), ExpandedRecordHeader::nfields, and unlikely.

Referenced by expanded_record_get_field().

expanded_record_fetch_tupdesc()

TupleDesc expanded_record_fetch_tupdesc

(

ExpandedRecordHeader *

erh

)

Definition at line 824 of file expandedrecord.c.

{
    TupleDesc   tupdesc;
 
    /* Easy if we already have it (but caller should have checked already) */
    if (erh->er_tupdesc)
        return erh->er_tupdesc;
 
    /* Lookup the composite type's tupdesc using the typcache */
    tupdesc = lookup_rowtype_tupdesc(erh->er_typeid, erh->er_typmod);
 
    /*
     * If it's a refcounted tupdesc rather than a statically allocated one, we
     * want to manage the refcount with a memory context callback rather than
     * assuming that the CurrentResourceOwner is longer-lived than this
     * expanded object.
     */
    if (tupdesc->tdrefcount >= 0)
    {
        /* Register callback if we didn't already */
        if (erh->er_mcb.arg == NULL)
        {
            erh->er_mcb.func = ER_mc_callback;
            erh->er_mcb.arg = (void *) erh;
            MemoryContextRegisterResetCallback(erh->hdr.eoh_context,
                                               &erh->er_mcb);
        }
 
        /* Remember our own pointer */
        erh->er_tupdesc = tupdesc;
        tupdesc->tdrefcount++;
 
        /* Release the pin lookup_rowtype_tupdesc acquired */
        ReleaseTupleDesc(tupdesc);
    }
    else
    {
        /* Just remember the pointer */
        erh->er_tupdesc = tupdesc;
    }
 
    /* In either case, fetch the process-global ID for this tupdesc */
    erh->er_tupdesc_id = assign_record_type_identifier(tupdesc->tdtypeid,
                                                       tupdesc->tdtypmod);
 
    return tupdesc;
}

References MemoryContextCallback::arg, assign_record_type_identifier(), ExpandedObjectHeader::eoh_context, ER_mc_callback(), ExpandedRecordHeader::er_mcb, ExpandedRecordHeader::er_tupdesc, ExpandedRecordHeader::er_tupdesc_id, ExpandedRecordHeader::er_typeid, ExpandedRecordHeader::er_typmod, MemoryContextCallback::func, ExpandedRecordHeader::hdr, lookup_rowtype_tupdesc(), MemoryContextRegisterResetCallback(), ReleaseTupleDesc, TupleDescData::tdrefcount, TupleDescData::tdtypeid, and TupleDescData::tdtypmod.

Referenced by expanded_record_get_tupdesc().

expanded_record_get_field()

static Datum expanded_record_get_field ( ExpandedRecordHeader *  erh, int  fnumber, bool *  isnull  )

inlinestatic

Definition at line 228 of file expandedrecord.h.

{
    if ((erh->flags & ER_FLAG_DVALUES_VALID) &&
        likely(fnumber > 0 && fnumber <= erh->nfields))
    {
        *isnull = erh->dnulls[fnumber - 1];
        return erh->dvalues[fnumber - 1];
    }
    else
        return expanded_record_fetch_field(erh, fnumber, isnull);
}

References ExpandedRecordHeader::dnulls, ExpandedRecordHeader::dvalues, ER_FLAG_DVALUES_VALID, expanded_record_fetch_field(), ExpandedRecordHeader::flags, and likely.

Referenced by exec_eval_datum(), ExecEvalFieldSelect(), and plpgsql_param_eval_recfield().

expanded_record_get_tupdesc()

static TupleDesc expanded_record_get_tupdesc ( ExpandedRecordHeader *  erh )

inlinestatic

Definition at line 218 of file expandedrecord.h.

{
    if (likely(erh->er_tupdesc != NULL))
        return erh->er_tupdesc;
    else
        return expanded_record_fetch_tupdesc(erh);
}

References ExpandedRecordHeader::er_tupdesc, expanded_record_fetch_tupdesc(), and likely.

Referenced by build_dummy_expanded_header(), coerce_function_result_tuple(), deconstruct_expanded_record(), ER_flatten_into(), ER_get_flat_size(), exec_for_query(), exec_move_row(), exec_move_row_from_datum(), exec_move_row_from_fields(), exec_stmt_return_next(), ExecEvalFieldSelect(), expanded_record_lookup_field(), make_expanded_record_for_rec(), make_expanded_record_from_exprecord(), and plpgsql_exec_trigger().

expanded_record_get_tuple()

HeapTuple expanded_record_get_tuple

(

ExpandedRecordHeader *

erh

)

Definition at line 884 of file expandedrecord.c.

{
    /* Easy case if we still have original tuple */
    if (erh->flags & ER_FLAG_FVALUE_VALID)
        return erh->fvalue;
 
    /* Else just build a tuple from datums */
    if (erh->flags & ER_FLAG_DVALUES_VALID)
        return heap_form_tuple(erh->er_tupdesc, erh->dvalues, erh->dnulls);
 
    /* Expanded record is empty */
    return NULL;
}

References ExpandedRecordHeader::dnulls, ExpandedRecordHeader::dvalues, ER_FLAG_DVALUES_VALID, ER_FLAG_FVALUE_VALID, ExpandedRecordHeader::er_tupdesc, ExpandedRecordHeader::flags, ExpandedRecordHeader::fvalue, and heap_form_tuple().

Referenced by coerce_function_result_tuple(), exec_stmt_return_next(), and plpgsql_exec_trigger().

expanded_record_lookup_field()

bool expanded_record_lookup_field	(	ExpandedRecordHeader *	erh,
		const char *	fieldname,
		ExpandedRecordFieldInfo *	finfo
	)

Definition at line 1017 of file expandedrecord.c.

{
    TupleDesc   tupdesc;
    int         fno;
    Form_pg_attribute attr;
    const FormData_pg_attribute *sysattr;
 
    tupdesc = expanded_record_get_tupdesc(erh);
 
    /* First, check user-defined attributes */
    for (fno = 0; fno < tupdesc->natts; fno++)
    {
        attr = TupleDescAttr(tupdesc, fno);
        if (namestrcmp(&attr->attname, fieldname) == 0 &&
            !attr->attisdropped)
        {
            finfo->fnumber = attr->attnum;
            finfo->ftypeid = attr->atttypid;
            finfo->ftypmod = attr->atttypmod;
            finfo->fcollation = attr->attcollation;
            return true;
        }
    }
 
    /* How about system attributes? */
    sysattr = SystemAttributeByName(fieldname);
    if (sysattr != NULL)
    {
        finfo->fnumber = sysattr->attnum;
        finfo->ftypeid = sysattr->atttypid;
        finfo->ftypmod = sysattr->atttypmod;
        finfo->fcollation = sysattr->attcollation;
        return true;
    }
 
    return false;
}

References expanded_record_get_tupdesc(), ExpandedRecordFieldInfo::fcollation, ExpandedRecordFieldInfo::fnumber, FormData_pg_attribute, ExpandedRecordFieldInfo::ftypeid, ExpandedRecordFieldInfo::ftypmod, namestrcmp(), TupleDescData::natts, SystemAttributeByName(), and TupleDescAttr.

Referenced by exec_assign_value(), exec_eval_datum(), plpgsql_exec_get_datum_type(), plpgsql_exec_get_datum_type_info(), plpgsql_param_eval_recfield(), and plpgsql_param_fetch().

expanded_record_set_field_internal()

void expanded_record_set_field_internal	(	ExpandedRecordHeader *	erh,
		int	fnumber,
		Datum	newValue,
		bool	isnull,
		bool	expand_external,
		bool	check_constraints
	)

Definition at line 1112 of file expandedrecord.c.

{
    TupleDesc   tupdesc;
    Form_pg_attribute attr;
    Datum      *dvalues;
    bool       *dnulls;
    char       *oldValue;
 
    /*
     * Shouldn't ever be trying to assign new data to a dummy header, except
     * in the case of an internal call for field inlining.
     */
    Assert(!(erh->flags & ER_FLAG_IS_DUMMY) || !check_constraints);
 
    /* Before performing the assignment, see if result will satisfy domain */
    if ((erh->flags & ER_FLAG_IS_DOMAIN) && check_constraints)
        check_domain_for_new_field(erh, fnumber, newValue, isnull);
 
    /* If we haven't yet deconstructed the tuple, do that */
    if (!(erh->flags & ER_FLAG_DVALUES_VALID))
        deconstruct_expanded_record(erh);
 
    /* Tuple descriptor must be valid by now */
    tupdesc = erh->er_tupdesc;
    Assert(erh->nfields == tupdesc->natts);
 
    /* Caller error if fnumber is system column or nonexistent column */
    if (unlikely(fnumber <= 0 || fnumber > erh->nfields))
        elog(ERROR, "cannot assign to field %d of expanded record", fnumber);
 
    /*
     * Copy new field value into record's context, and deal with detoasting,
     * if needed.
     */
    attr = TupleDescAttr(tupdesc, fnumber - 1);
    if (!isnull && !attr->attbyval)
    {
        MemoryContext oldcxt;
 
        /* If requested, detoast any external value */
        if (expand_external)
        {
            if (attr->attlen == -1 &&
                VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
            {
                /* Detoasting should be done in short-lived context. */
                oldcxt = MemoryContextSwitchTo(get_short_term_cxt(erh));
                newValue = PointerGetDatum(detoast_external_attr((struct varlena *) DatumGetPointer(newValue)));
                MemoryContextSwitchTo(oldcxt);
            }
            else
                expand_external = false;    /* need not clean up below */
        }
 
        /* Copy value into record's context */
        oldcxt = MemoryContextSwitchTo(erh->hdr.eoh_context);
        newValue = datumCopy(newValue, false, attr->attlen);
        MemoryContextSwitchTo(oldcxt);
 
        /* We can now flush anything that detoasting might have leaked */
        if (expand_external)
            MemoryContextReset(erh->er_short_term_cxt);
 
        /* Remember that we have field(s) that may need to be pfree'd */
        erh->flags |= ER_FLAG_DVALUES_ALLOCED;
 
        /*
         * While we're here, note whether it's an external toasted value,
         * because that could mean we need to inline it later.  (Think not to
         * merge this into the previous expand_external logic: datumCopy could
         * by itself have made the value non-external.)
         */
        if (attr->attlen == -1 &&
            VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
            erh->flags |= ER_FLAG_HAVE_EXTERNAL;
    }
 
    /*
     * We're ready to make irreversible changes.
     */
    dvalues = erh->dvalues;
    dnulls = erh->dnulls;
 
    /* Flattened value will no longer represent record accurately */
    erh->flags &= ~ER_FLAG_FVALUE_VALID;
    /* And we don't know the flattened size either */
    erh->flat_size = 0;
 
    /* Grab old field value for pfree'ing, if needed. */
    if (!attr->attbyval && !dnulls[fnumber - 1])
        oldValue = (char *) DatumGetPointer(dvalues[fnumber - 1]);
    else
        oldValue = NULL;
 
    /* And finally we can insert the new field. */
    dvalues[fnumber - 1] = newValue;
    dnulls[fnumber - 1] = isnull;
 
    /*
     * Free old field if needed; this keeps repeated field replacements from
     * bloating the record's storage.  If the pfree somehow fails, it won't
     * corrupt the record.
     *
     * If we're updating a dummy header, we can't risk pfree'ing the old
     * value, because most likely the expanded record's main header still has
     * a pointer to it.  This won't result in any sustained memory leak, since
     * whatever we just allocated here is in the short-lived domain check
     * context.
     */
    if (oldValue && !(erh->flags & ER_FLAG_IS_DUMMY))
    {
        /* Don't try to pfree a part of the original flat record */
        if (oldValue < erh->fstartptr || oldValue >= erh->fendptr)
            pfree(oldValue);
    }
}

References Assert, check_domain_for_new_field(), datumCopy(), DatumGetPointer(), deconstruct_expanded_record(), detoast_external_attr(), ExpandedRecordHeader::dnulls, ExpandedRecordHeader::dvalues, elog, ExpandedObjectHeader::eoh_context, ER_FLAG_DVALUES_ALLOCED, ER_FLAG_DVALUES_VALID, ER_FLAG_FVALUE_VALID, ER_FLAG_HAVE_EXTERNAL, ER_FLAG_IS_DOMAIN, ER_FLAG_IS_DUMMY, ExpandedRecordHeader::er_short_term_cxt, ExpandedRecordHeader::er_tupdesc, ERROR, ExpandedRecordHeader::fendptr, ExpandedRecordHeader::flags, ExpandedRecordHeader::flat_size, get_short_term_cxt(), ExpandedRecordHeader::hdr, MemoryContextReset(), MemoryContextSwitchTo(), TupleDescData::natts, ExpandedRecordHeader::nfields, pfree(), PointerGetDatum(), TupleDescAttr, unlikely, and VARATT_IS_EXTERNAL.

Referenced by ER_get_flat_size(), and plpgsql_exec_trigger().

expanded_record_set_fields()

void expanded_record_set_fields	(	ExpandedRecordHeader *	erh,
		const Datum *	newValues,
		const bool *	isnulls,
		bool	expand_external
	)

Definition at line 1249 of file expandedrecord.c.

{
    TupleDesc   tupdesc;
    Datum      *dvalues;
    bool       *dnulls;
    int         fnumber;
    MemoryContext oldcxt;
 
    /* Shouldn't ever be trying to assign new data to a dummy header */
    Assert(!(erh->flags & ER_FLAG_IS_DUMMY));
 
    /* If we haven't yet deconstructed the tuple, do that */
    if (!(erh->flags & ER_FLAG_DVALUES_VALID))
        deconstruct_expanded_record(erh);
 
    /* Tuple descriptor must be valid by now */
    tupdesc = erh->er_tupdesc;
    Assert(erh->nfields == tupdesc->natts);
 
    /* Flattened value will no longer represent record accurately */
    erh->flags &= ~ER_FLAG_FVALUE_VALID;
    /* And we don't know the flattened size either */
    erh->flat_size = 0;
 
    oldcxt = MemoryContextSwitchTo(erh->hdr.eoh_context);
 
    dvalues = erh->dvalues;
    dnulls = erh->dnulls;
 
    for (fnumber = 0; fnumber < erh->nfields; fnumber++)
    {
        Form_pg_attribute attr = TupleDescAttr(tupdesc, fnumber);
        Datum       newValue;
        bool        isnull;
 
        /* Ignore dropped columns */
        if (attr->attisdropped)
            continue;
 
        newValue = newValues[fnumber];
        isnull = isnulls[fnumber];
 
        if (!attr->attbyval)
        {
            /*
             * Copy new field value into record's context, and deal with
             * detoasting, if needed.
             */
            if (!isnull)
            {
                /* Is it an external toasted value? */
                if (attr->attlen == -1 &&
                    VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
                {
                    if (expand_external)
                    {
                        /* Detoast as requested while copying the value */
                        newValue = PointerGetDatum(detoast_external_attr((struct varlena *) DatumGetPointer(newValue)));
                    }
                    else
                    {
                        /* Just copy the value */
                        newValue = datumCopy(newValue, false, -1);
                        /* If it's still external, remember that */
                        if (VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
                            erh->flags |= ER_FLAG_HAVE_EXTERNAL;
                    }
                }
                else
                {
                    /* Not an external value, just copy it */
                    newValue = datumCopy(newValue, false, attr->attlen);
                }
 
                /* Remember that we have field(s) that need to be pfree'd */
                erh->flags |= ER_FLAG_DVALUES_ALLOCED;
            }
 
            /*
             * Free old field value, if any (not likely, since really we ought
             * to be inserting into an empty record).
             */
            if (unlikely(!dnulls[fnumber]))
            {
                char       *oldValue;
 
                oldValue = (char *) DatumGetPointer(dvalues[fnumber]);
                /* Don't try to pfree a part of the original flat record */
                if (oldValue < erh->fstartptr || oldValue >= erh->fendptr)
                    pfree(oldValue);
            }
        }
 
        /* And finally we can insert the new field. */
        dvalues[fnumber] = newValue;
        dnulls[fnumber] = isnull;
    }
 
    /*
     * Because we don't guarantee atomicity of set_fields(), we can just leave
     * checking of domain constraints to occur as the final step; if it throws
     * an error, too bad.
     */
    if (erh->flags & ER_FLAG_IS_DOMAIN)
    {
        /* We run domain_check in a short-lived context to limit cruft */
        MemoryContextSwitchTo(get_short_term_cxt(erh));
 
        domain_check(ExpandedRecordGetRODatum(erh), false,
                     erh->er_decltypeid,
                     &erh->er_domaininfo,
                     erh->hdr.eoh_context);
    }
 
    MemoryContextSwitchTo(oldcxt);
}

References Assert, datumCopy(), DatumGetPointer(), deconstruct_expanded_record(), detoast_external_attr(), ExpandedRecordHeader::dnulls, domain_check(), ExpandedRecordHeader::dvalues, ExpandedObjectHeader::eoh_context, ExpandedRecordHeader::er_decltypeid, ExpandedRecordHeader::er_domaininfo, ER_FLAG_DVALUES_ALLOCED, ER_FLAG_DVALUES_VALID, ER_FLAG_FVALUE_VALID, ER_FLAG_HAVE_EXTERNAL, ER_FLAG_IS_DOMAIN, ER_FLAG_IS_DUMMY, ExpandedRecordHeader::er_tupdesc, ExpandedRecordGetRODatum(), ExpandedRecordHeader::fendptr, ExpandedRecordHeader::flags, ExpandedRecordHeader::flat_size, get_short_term_cxt(), ExpandedRecordHeader::hdr, MemoryContextSwitchTo(), TupleDescData::natts, ExpandedRecordHeader::nfields, pfree(), PointerGetDatum(), TupleDescAttr, unlikely, and VARATT_IS_EXTERNAL.

Referenced by exec_move_row_from_fields().

expanded_record_set_tuple()

void expanded_record_set_tuple	(	ExpandedRecordHeader *	erh,
		HeapTuple	tuple,
		bool	copy,
		bool	expand_external
	)

Definition at line 440 of file expandedrecord.c.

{
    int         oldflags;
    HeapTuple   oldtuple;
    char       *oldfstartptr;
    char       *oldfendptr;
    int         newflags;
    HeapTuple   newtuple;
    MemoryContext oldcxt;
 
    /* Shouldn't ever be trying to assign new data to a dummy header */
    Assert(!(erh->flags & ER_FLAG_IS_DUMMY));
 
    /*
     * Before performing the assignment, see if result will satisfy domain.
     */
    if (erh->flags & ER_FLAG_IS_DOMAIN)
        check_domain_for_new_tuple(erh, tuple);
 
    /*
     * If we need to get rid of out-of-line field values, do so, using the
     * short-term context to avoid leaking whatever cruft the toast fetch
     * might generate.
     */
    if (expand_external && tuple)
    {
        /* Assert caller didn't ask for unsupported case */
        Assert(copy);
        if (HeapTupleHasExternal(tuple))
        {
            oldcxt = MemoryContextSwitchTo(get_short_term_cxt(erh));
            tuple = toast_flatten_tuple(tuple, erh->er_tupdesc);
            MemoryContextSwitchTo(oldcxt);
        }
        else
            expand_external = false;    /* need not clean up below */
    }
 
    /*
     * Initialize new flags, keeping only non-data status bits.
     */
    oldflags = erh->flags;
    newflags = oldflags & ER_FLAGS_NON_DATA;
 
    /*
     * Copy tuple into local storage if needed.  We must be sure this succeeds
     * before we start to modify the expanded record's state.
     */
    if (copy && tuple)
    {
        oldcxt = MemoryContextSwitchTo(erh->hdr.eoh_context);
        newtuple = heap_copytuple(tuple);
        newflags |= ER_FLAG_FVALUE_ALLOCED;
        MemoryContextSwitchTo(oldcxt);
 
        /* We can now flush anything that detoasting might have leaked. */
        if (expand_external)
            MemoryContextReset(erh->er_short_term_cxt);
    }
    else
        newtuple = tuple;
 
    /* Make copies of fields we're about to overwrite */
    oldtuple = erh->fvalue;
    oldfstartptr = erh->fstartptr;
    oldfendptr = erh->fendptr;
 
    /*
     * It's now safe to update the expanded record's state.
     */
    if (newtuple)
    {
        /* Save flat representation */
        erh->fvalue = newtuple;
        erh->fstartptr = (char *) newtuple->t_data;
        erh->fendptr = ((char *) newtuple->t_data) + newtuple->t_len;
        newflags |= ER_FLAG_FVALUE_VALID;
 
        /* Remember if we have any out-of-line field values */
        if (HeapTupleHasExternal(newtuple))
            newflags |= ER_FLAG_HAVE_EXTERNAL;
    }
    else
    {
        erh->fvalue = NULL;
        erh->fstartptr = erh->fendptr = NULL;
    }
 
    erh->flags = newflags;
 
    /* Reset flat-size info; we don't bother to make it valid now */
    erh->flat_size = 0;
 
    /*
     * Now, release any storage belonging to old field values.  It's safe to
     * do this because ER_FLAG_DVALUES_VALID is no longer set in erh->flags;
     * even if we fail partway through, the record is valid, and at worst
     * we've failed to reclaim some space.
     */
    if (oldflags & ER_FLAG_DVALUES_ALLOCED)
    {
        TupleDesc   tupdesc = erh->er_tupdesc;
        int         i;
 
        for (i = 0; i < erh->nfields; i++)
        {
            if (!erh->dnulls[i] &&
                !(TupleDescAttr(tupdesc, i)->attbyval))
            {
                char       *oldValue = (char *) DatumGetPointer(erh->dvalues[i]);
 
                if (oldValue < oldfstartptr || oldValue >= oldfendptr)
                    pfree(oldValue);
            }
        }
    }
 
    /* Likewise free the old tuple, if it was locally allocated */
    if (oldflags & ER_FLAG_FVALUE_ALLOCED)
        heap_freetuple(oldtuple);
 
    /* We won't make a new deconstructed representation until/unless needed */
}

References Assert, attbyval, check_domain_for_new_tuple(), DatumGetPointer(), ExpandedRecordHeader::dnulls, ExpandedRecordHeader::dvalues, ExpandedObjectHeader::eoh_context, ER_FLAG_DVALUES_ALLOCED, ER_FLAG_FVALUE_ALLOCED, ER_FLAG_FVALUE_VALID, ER_FLAG_HAVE_EXTERNAL, ER_FLAG_IS_DOMAIN, ER_FLAG_IS_DUMMY, ER_FLAGS_NON_DATA, ExpandedRecordHeader::er_short_term_cxt, ExpandedRecordHeader::er_tupdesc, ExpandedRecordHeader::fendptr, ExpandedRecordHeader::flags, ExpandedRecordHeader::flat_size, ExpandedRecordHeader::fstartptr, ExpandedRecordHeader::fvalue, get_short_term_cxt(), ExpandedRecordHeader::hdr, heap_copytuple(), heap_freetuple(), HeapTupleHasExternal, i, if(), MemoryContextReset(), MemoryContextSwitchTo(), ExpandedRecordHeader::nfields, pfree(), HeapTupleData::t_data, HeapTupleData::t_len, toast_flatten_tuple(), and TupleDescAttr.

Referenced by exec_for_query(), exec_move_row(), exec_move_row_from_datum(), and plpgsql_exec_trigger().

ExpandedRecordGetDatum()

static Datum ExpandedRecordGetDatum ( const ExpandedRecordHeader *  erh )

inlinestatic

Definition at line 143 of file expandedrecord.h.

{
    return EOHPGetRWDatum(&erh->hdr);
}

References EOHPGetRWDatum(), and ExpandedRecordHeader::hdr.

Referenced by assign_record_var(), exec_eval_datum(), exec_move_row(), and exec_stmt_return().

ExpandedRecordGetRODatum()

static Datum ExpandedRecordGetRODatum ( const ExpandedRecordHeader *  erh )

inlinestatic

Definition at line 149 of file expandedrecord.h.

{
    return EOHPGetRODatum(&erh->hdr);
}

References EOHPGetRODatum(), and ExpandedRecordHeader::hdr.

Referenced by check_domain_for_new_field(), check_domain_for_new_tuple(), and expanded_record_set_fields().

make_expanded_record_from_datum()

Datum make_expanded_record_from_datum	(	Datum	recorddatum,
		MemoryContext	parentcontext
	)

Definition at line 580 of file expandedrecord.c.

{
    ExpandedRecordHeader *erh;
    HeapTupleHeader tuphdr;
    HeapTupleData tmptup;
    HeapTuple   newtuple;
    MemoryContext objcxt;
    MemoryContext oldcxt;
 
    /*
     * Allocate private context for expanded object.  We use a regular-size
     * context, not a small one, to improve the odds that we can fit a tupdesc
     * into it without needing an extra malloc block.
     */
    objcxt = AllocSetContextCreate(parentcontext,
                                   "expanded record",
                                   ALLOCSET_DEFAULT_SIZES);
 
    /* Set up expanded record header, initializing fields to 0/null */
    erh = (ExpandedRecordHeader *)
        MemoryContextAllocZero(objcxt, sizeof(ExpandedRecordHeader));
 
    EOH_init_header(&erh->hdr, &ER_methods, objcxt);
    erh->er_magic = ER_MAGIC;
 
    /*
     * Detoast and copy source record into private context, as a HeapTuple.
     * (If we actually have to detoast the source, we'll leak some memory in
     * the caller's context, but it doesn't seem worth worrying about.)
     */
    tuphdr = DatumGetHeapTupleHeader(recorddatum);
 
    tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
    ItemPointerSetInvalid(&(tmptup.t_self));
    tmptup.t_tableOid = InvalidOid;
    tmptup.t_data = tuphdr;
 
    oldcxt = MemoryContextSwitchTo(objcxt);
    newtuple = heap_copytuple(&tmptup);
    erh->flags |= ER_FLAG_FVALUE_ALLOCED;
    MemoryContextSwitchTo(oldcxt);
 
    /* Fill in composite-type identification info */
    erh->er_decltypeid = erh->er_typeid = HeapTupleHeaderGetTypeId(tuphdr);
    erh->er_typmod = HeapTupleHeaderGetTypMod(tuphdr);
 
    /* remember we have a flat representation */
    erh->fvalue = newtuple;
    erh->fstartptr = (char *) newtuple->t_data;
    erh->fendptr = ((char *) newtuple->t_data) + newtuple->t_len;
    erh->flags |= ER_FLAG_FVALUE_VALID;
 
    /* Shouldn't need to set ER_FLAG_HAVE_EXTERNAL */
    Assert(!HeapTupleHeaderHasExternal(tuphdr));
 
    /*
     * We won't look up the tupdesc till we have to, nor make a deconstructed
     * representation.  We don't have enough info to fill flat_size and
     * friends, either.
     */
 
    /* return a R/W pointer to the expanded record */
    return EOHPGetRWDatum(&erh->hdr);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, DatumGetHeapTupleHeader, EOH_init_header(), EOHPGetRWDatum(), ExpandedRecordHeader::er_decltypeid, ER_FLAG_FVALUE_ALLOCED, ER_FLAG_FVALUE_VALID, ER_MAGIC, ExpandedRecordHeader::er_magic, ER_methods, ExpandedRecordHeader::er_typeid, ExpandedRecordHeader::er_typmod, ExpandedRecordHeader::fendptr, ExpandedRecordHeader::flags, ExpandedRecordHeader::fstartptr, ExpandedRecordHeader::fvalue, ExpandedRecordHeader::hdr, heap_copytuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, HeapTupleHeaderHasExternal, InvalidOid, ItemPointerSetInvalid(), MemoryContextAllocZero(), MemoryContextSwitchTo(), HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

Referenced by DatumGetExpandedRecord().

make_expanded_record_from_exprecord()

ExpandedRecordHeader* make_expanded_record_from_exprecord	(	ExpandedRecordHeader *	olderh,
		MemoryContext	parentcontext
	)

Definition at line 329 of file expandedrecord.c.

{
    ExpandedRecordHeader *erh;
    TupleDesc   tupdesc = expanded_record_get_tupdesc(olderh);
    MemoryContext objcxt;
    MemoryContext oldcxt;
    char       *chunk;
 
    /*
     * Allocate private context for expanded object.  We use a regular-size
     * context, not a small one, to improve the odds that we can fit a tupdesc
     * into it without needing an extra malloc block.
     */
    objcxt = AllocSetContextCreate(parentcontext,
                                   "expanded record",
                                   ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Since we already know the number of fields in the tupdesc, we can
     * allocate the dvalues/dnulls arrays along with the record header.  This
     * is useless if we never need those arrays, but it costs almost nothing,
     * and it will save a palloc cycle if we do need them.
     */
    erh = (ExpandedRecordHeader *)
        MemoryContextAlloc(objcxt, MAXALIGN(sizeof(ExpandedRecordHeader))
                           + tupdesc->natts * (sizeof(Datum) + sizeof(bool)));
 
    /* Ensure all header fields are initialized to 0/null */
    memset(erh, 0, sizeof(ExpandedRecordHeader));
 
    EOH_init_header(&erh->hdr, &ER_methods, objcxt);
    erh->er_magic = ER_MAGIC;
 
    /* Set up dvalues/dnulls, with no valid contents as yet */
    chunk = (char *) erh + MAXALIGN(sizeof(ExpandedRecordHeader));
    erh->dvalues = (Datum *) chunk;
    erh->dnulls = (bool *) (chunk + tupdesc->natts * sizeof(Datum));
    erh->nfields = tupdesc->natts;
 
    /* Fill in composite-type identification info */
    erh->er_decltypeid = olderh->er_decltypeid;
    erh->er_typeid = olderh->er_typeid;
    erh->er_typmod = olderh->er_typmod;
    erh->er_tupdesc_id = olderh->er_tupdesc_id;
 
    /* The only flag bit that transfers over is IS_DOMAIN */
    erh->flags = olderh->flags & ER_FLAG_IS_DOMAIN;
 
    /*
     * Copy tupdesc if needed, but we prefer to bump its refcount if possible.
     * We manage the refcount with a memory context callback rather than
     * assuming that the CurrentResourceOwner is longer-lived than this
     * expanded object.
     */
    if (tupdesc->tdrefcount >= 0)
    {
        /* Register callback to release the refcount */
        erh->er_mcb.func = ER_mc_callback;
        erh->er_mcb.arg = (void *) erh;
        MemoryContextRegisterResetCallback(erh->hdr.eoh_context,
                                           &erh->er_mcb);
 
        /* And save the pointer */
        erh->er_tupdesc = tupdesc;
        tupdesc->tdrefcount++;
    }
    else if (olderh->flags & ER_FLAG_TUPDESC_ALLOCED)
    {
        /* We need to make our own copy of the tupdesc */
        oldcxt = MemoryContextSwitchTo(objcxt);
        erh->er_tupdesc = CreateTupleDescCopy(tupdesc);
        erh->flags |= ER_FLAG_TUPDESC_ALLOCED;
        MemoryContextSwitchTo(oldcxt);
    }
    else
    {
        /*
         * Assume the tupdesc will outlive this expanded object, just like
         * we're assuming it will outlive the source object.
         */
        erh->er_tupdesc = tupdesc;
    }
 
    /*
     * We don't set ER_FLAG_DVALUES_VALID or ER_FLAG_FVALUE_VALID, so the
     * record remains logically empty.
     */
 
    return erh;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, MemoryContextCallback::arg, chunk, CreateTupleDescCopy(), ExpandedRecordHeader::dnulls, ExpandedRecordHeader::dvalues, ExpandedObjectHeader::eoh_context, EOH_init_header(), ExpandedRecordHeader::er_decltypeid, ER_FLAG_IS_DOMAIN, ER_FLAG_TUPDESC_ALLOCED, ER_MAGIC, ExpandedRecordHeader::er_magic, ER_mc_callback(), ExpandedRecordHeader::er_mcb, ER_methods, ExpandedRecordHeader::er_tupdesc, ExpandedRecordHeader::er_tupdesc_id, ExpandedRecordHeader::er_typeid, ExpandedRecordHeader::er_typmod, expanded_record_get_tupdesc(), ExpandedRecordHeader::flags, MemoryContextCallback::func, ExpandedRecordHeader::hdr, MAXALIGN, MemoryContextAlloc(), MemoryContextRegisterResetCallback(), MemoryContextSwitchTo(), TupleDescData::natts, ExpandedRecordHeader::nfields, and TupleDescData::tdrefcount.

Referenced by make_expanded_record_for_rec(), and plpgsql_exec_trigger().

make_expanded_record_from_tupdesc()

ExpandedRecordHeader* make_expanded_record_from_tupdesc	(	TupleDesc	tupdesc,
		MemoryContext	parentcontext
	)

Definition at line 205 of file expandedrecord.c.

{
    ExpandedRecordHeader *erh;
    uint64      tupdesc_id;
    MemoryContext objcxt;
    MemoryContext oldcxt;
    char       *chunk;
 
    if (tupdesc->tdtypeid != RECORDOID)
    {
        /*
         * If it's a named composite type (not RECORD), we prefer to reference
         * the typcache's copy of the tupdesc, which is guaranteed to be
         * refcounted (the given tupdesc might not be).  In any case, we need
         * to consult the typcache to get the correct tupdesc identifier.
         *
         * Note that tdtypeid couldn't be a domain type, so we need not
         * consider that case here.
         */
        TypeCacheEntry *typentry;
 
        typentry = lookup_type_cache(tupdesc->tdtypeid, TYPECACHE_TUPDESC);
        if (typentry->tupDesc == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("type %s is not composite",
                            format_type_be(tupdesc->tdtypeid))));
        tupdesc = typentry->tupDesc;
        tupdesc_id = typentry->tupDesc_identifier;
    }
    else
    {
        /*
         * For RECORD types, get the appropriate unique identifier (possibly
         * freshly assigned).
         */
        tupdesc_id = assign_record_type_identifier(tupdesc->tdtypeid,
                                                   tupdesc->tdtypmod);
    }
 
    /*
     * Allocate private context for expanded object.  We use a regular-size
     * context, not a small one, to improve the odds that we can fit a tupdesc
     * into it without needing an extra malloc block.
     */
    objcxt = AllocSetContextCreate(parentcontext,
                                   "expanded record",
                                   ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Since we already know the number of fields in the tupdesc, we can
     * allocate the dvalues/dnulls arrays along with the record header.  This
     * is useless if we never need those arrays, but it costs almost nothing,
     * and it will save a palloc cycle if we do need them.
     */
    erh = (ExpandedRecordHeader *)
        MemoryContextAlloc(objcxt, MAXALIGN(sizeof(ExpandedRecordHeader))
                           + tupdesc->natts * (sizeof(Datum) + sizeof(bool)));
 
    /* Ensure all header fields are initialized to 0/null */
    memset(erh, 0, sizeof(ExpandedRecordHeader));
 
    EOH_init_header(&erh->hdr, &ER_methods, objcxt);
    erh->er_magic = ER_MAGIC;
 
    /* Set up dvalues/dnulls, with no valid contents as yet */
    chunk = (char *) erh + MAXALIGN(sizeof(ExpandedRecordHeader));
    erh->dvalues = (Datum *) chunk;
    erh->dnulls = (bool *) (chunk + tupdesc->natts * sizeof(Datum));
    erh->nfields = tupdesc->natts;
 
    /* Fill in composite-type identification info */
    erh->er_decltypeid = erh->er_typeid = tupdesc->tdtypeid;
    erh->er_typmod = tupdesc->tdtypmod;
    erh->er_tupdesc_id = tupdesc_id;
 
    /*
     * Copy tupdesc if needed, but we prefer to bump its refcount if possible.
     * We manage the refcount with a memory context callback rather than
     * assuming that the CurrentResourceOwner is longer-lived than this
     * expanded object.
     */
    if (tupdesc->tdrefcount >= 0)
    {
        /* Register callback to release the refcount */
        erh->er_mcb.func = ER_mc_callback;
        erh->er_mcb.arg = (void *) erh;
        MemoryContextRegisterResetCallback(erh->hdr.eoh_context,
                                           &erh->er_mcb);
 
        /* And save the pointer */
        erh->er_tupdesc = tupdesc;
        tupdesc->tdrefcount++;
    }
    else
    {
        /* Just copy it */
        oldcxt = MemoryContextSwitchTo(objcxt);
        erh->er_tupdesc = CreateTupleDescCopy(tupdesc);
        erh->flags |= ER_FLAG_TUPDESC_ALLOCED;
        MemoryContextSwitchTo(oldcxt);
    }
 
    /*
     * We don't set ER_FLAG_DVALUES_VALID or ER_FLAG_FVALUE_VALID, so the
     * record remains logically empty.
     */
 
    return erh;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, MemoryContextCallback::arg, assign_record_type_identifier(), chunk, CreateTupleDescCopy(), ExpandedRecordHeader::dnulls, ExpandedRecordHeader::dvalues, ExpandedObjectHeader::eoh_context, EOH_init_header(), ExpandedRecordHeader::er_decltypeid, ER_FLAG_TUPDESC_ALLOCED, ER_MAGIC, ExpandedRecordHeader::er_magic, ER_mc_callback(), ExpandedRecordHeader::er_mcb, ER_methods, ExpandedRecordHeader::er_tupdesc, ExpandedRecordHeader::er_tupdesc_id, ExpandedRecordHeader::er_typeid, ExpandedRecordHeader::er_typmod, ereport, errcode(), errmsg(), ERROR, ExpandedRecordHeader::flags, format_type_be(), MemoryContextCallback::func, ExpandedRecordHeader::hdr, lookup_type_cache(), MAXALIGN, MemoryContextAlloc(), MemoryContextRegisterResetCallback(), MemoryContextSwitchTo(), TupleDescData::natts, ExpandedRecordHeader::nfields, TupleDescData::tdrefcount, TupleDescData::tdtypeid, TupleDescData::tdtypmod, TypeCacheEntry::tupDesc, TypeCacheEntry::tupDesc_identifier, and TYPECACHE_TUPDESC.

Referenced by make_expanded_record_for_rec(), and plpgsql_exec_trigger().

make_expanded_record_from_typeid()

ExpandedRecordHeader* make_expanded_record_from_typeid	(	Oid	type_id,
		int32	typmod,
		MemoryContext	parentcontext
	)

Definition at line 69 of file expandedrecord.c.

{
    ExpandedRecordHeader *erh;
    int         flags = 0;
    TupleDesc   tupdesc;
    uint64      tupdesc_id;
    MemoryContext objcxt;
    char       *chunk;
 
    if (type_id != RECORDOID)
    {
        /*
         * Consult the typcache to see if it's a domain over composite, and in
         * any case to get the tupdesc and tupdesc identifier.
         */
        TypeCacheEntry *typentry;
 
        typentry = lookup_type_cache(type_id,
                                     TYPECACHE_TUPDESC |
                                     TYPECACHE_DOMAIN_BASE_INFO);
        if (typentry->typtype == TYPTYPE_DOMAIN)
        {
            flags |= ER_FLAG_IS_DOMAIN;
            typentry = lookup_type_cache(typentry->domainBaseType,
                                         TYPECACHE_TUPDESC);
        }
        if (typentry->tupDesc == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("type %s is not composite",
                            format_type_be(type_id))));
        tupdesc = typentry->tupDesc;
        tupdesc_id = typentry->tupDesc_identifier;
    }
    else
    {
        /*
         * For RECORD types, get the tupdesc and identifier from typcache.
         */
        tupdesc = lookup_rowtype_tupdesc(type_id, typmod);
        tupdesc_id = assign_record_type_identifier(type_id, typmod);
    }
 
    /*
     * Allocate private context for expanded object.  We use a regular-size
     * context, not a small one, to improve the odds that we can fit a tupdesc
     * into it without needing an extra malloc block.  (This code path doesn't
     * ever need to copy a tupdesc into the expanded record, but let's be
     * consistent with the other ways of making an expanded record.)
     */
    objcxt = AllocSetContextCreate(parentcontext,
                                   "expanded record",
                                   ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Since we already know the number of fields in the tupdesc, we can
     * allocate the dvalues/dnulls arrays along with the record header.  This
     * is useless if we never need those arrays, but it costs almost nothing,
     * and it will save a palloc cycle if we do need them.
     */
    erh = (ExpandedRecordHeader *)
        MemoryContextAlloc(objcxt, MAXALIGN(sizeof(ExpandedRecordHeader))
                           + tupdesc->natts * (sizeof(Datum) + sizeof(bool)));
 
    /* Ensure all header fields are initialized to 0/null */
    memset(erh, 0, sizeof(ExpandedRecordHeader));
 
    EOH_init_header(&erh->hdr, &ER_methods, objcxt);
    erh->er_magic = ER_MAGIC;
 
    /* Set up dvalues/dnulls, with no valid contents as yet */
    chunk = (char *) erh + MAXALIGN(sizeof(ExpandedRecordHeader));
    erh->dvalues = (Datum *) chunk;
    erh->dnulls = (bool *) (chunk + tupdesc->natts * sizeof(Datum));
    erh->nfields = tupdesc->natts;
 
    /* Fill in composite-type identification info */
    erh->er_decltypeid = type_id;
    erh->er_typeid = tupdesc->tdtypeid;
    erh->er_typmod = tupdesc->tdtypmod;
    erh->er_tupdesc_id = tupdesc_id;
 
    erh->flags = flags;
 
    /*
     * If what we got from the typcache is a refcounted tupdesc, we need to
     * acquire our own refcount on it.  We manage the refcount with a memory
     * context callback rather than assuming that the CurrentResourceOwner is
     * longer-lived than this expanded object.
     */
    if (tupdesc->tdrefcount >= 0)
    {
        /* Register callback to release the refcount */
        erh->er_mcb.func = ER_mc_callback;
        erh->er_mcb.arg = (void *) erh;
        MemoryContextRegisterResetCallback(erh->hdr.eoh_context,
                                           &erh->er_mcb);
 
        /* And save the pointer */
        erh->er_tupdesc = tupdesc;
        tupdesc->tdrefcount++;
 
        /* If we called lookup_rowtype_tupdesc, release the pin it took */
        if (type_id == RECORDOID)
            ReleaseTupleDesc(tupdesc);
    }
    else
    {
        /*
         * If it's not refcounted, just assume it will outlive the expanded
         * object.  (This can happen for shared record types, for instance.)
         */
        erh->er_tupdesc = tupdesc;
    }
 
    /*
     * We don't set ER_FLAG_DVALUES_VALID or ER_FLAG_FVALUE_VALID, so the
     * record remains logically empty.
     */
 
    return erh;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, MemoryContextCallback::arg, assign_record_type_identifier(), chunk, ExpandedRecordHeader::dnulls, TypeCacheEntry::domainBaseType, ExpandedRecordHeader::dvalues, ExpandedObjectHeader::eoh_context, EOH_init_header(), ExpandedRecordHeader::er_decltypeid, ER_FLAG_IS_DOMAIN, ER_MAGIC, ExpandedRecordHeader::er_magic, ER_mc_callback(), ExpandedRecordHeader::er_mcb, ER_methods, ExpandedRecordHeader::er_tupdesc, ExpandedRecordHeader::er_tupdesc_id, ExpandedRecordHeader::er_typeid, ExpandedRecordHeader::er_typmod, ereport, errcode(), errmsg(), ERROR, ExpandedRecordHeader::flags, format_type_be(), MemoryContextCallback::func, ExpandedRecordHeader::hdr, lookup_rowtype_tupdesc(), lookup_type_cache(), MAXALIGN, MemoryContextAlloc(), MemoryContextRegisterResetCallback(), TupleDescData::natts, ExpandedRecordHeader::nfields, ReleaseTupleDesc, TupleDescData::tdrefcount, TupleDescData::tdtypeid, TupleDescData::tdtypmod, TypeCacheEntry::tupDesc, TypeCacheEntry::tupDesc_identifier, TYPECACHE_DOMAIN_BASE_INFO, TYPECACHE_TUPDESC, and TypeCacheEntry::typtype.

Referenced by exec_move_row_from_datum(), instantiate_empty_record_variable(), and make_expanded_record_for_rec().