tupdesc.h File Reference

#include "access/attnum.h"
#include "catalog/pg_attribute.h"
#include "nodes/pg_list.h"

Include dependency graph for tupdesc.h:

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

Go to the source code of this file.

Data Structures
struct	AttrDefault
struct	ConstrCheck
struct	TupleConstr
struct	TupleDescData

Macros
#define	TupleDescAttr(tupdesc, i)   (&(tupdesc)->attrs[(i)])
#define	TupleDescSize(src)
#define	PinTupleDesc(tupdesc)
#define	ReleaseTupleDesc(tupdesc)

Typedefs
typedef struct AttrDefault	AttrDefault
typedef struct ConstrCheck	ConstrCheck
typedef struct TupleConstr	TupleConstr
typedef struct TupleDescData	TupleDescData
typedef struct TupleDescData *	TupleDesc

Functions
TupleDesc	CreateTemplateTupleDesc (int natts)
TupleDesc	CreateTupleDesc (int natts, Form_pg_attribute *attrs)
TupleDesc	CreateTupleDescCopy (TupleDesc tupdesc)
TupleDesc	CreateTupleDescCopyConstr (TupleDesc tupdesc)
void	TupleDescCopy (TupleDesc dst, TupleDesc src)
void	TupleDescCopyEntry (TupleDesc dst, AttrNumber dstAttno, TupleDesc src, AttrNumber srcAttno)
void	FreeTupleDesc (TupleDesc tupdesc)
void	IncrTupleDescRefCount (TupleDesc tupdesc)
void	DecrTupleDescRefCount (TupleDesc tupdesc)
bool	equalTupleDescs (TupleDesc tupdesc1, TupleDesc tupdesc2)
uint32	hashTupleDesc (TupleDesc desc)
void	TupleDescInitEntry (TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
void	TupleDescInitBuiltinEntry (TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
void	TupleDescInitEntryCollation (TupleDesc desc, AttrNumber attributeNumber, Oid collationid)
TupleDesc	BuildDescForRelation (List *schema)
TupleDesc	BuildDescFromLists (List *names, List *types, List *typmods, List *collations)

Macro Definition Documentation

PinTupleDesc

#define PinTupleDesc

(

tupdesc

)

Value:

    do { \
        if ((tupdesc)->tdrefcount >= 0) \
            IncrTupleDescRefCount(tupdesc); \
    } while (0)

Definition at line 116 of file tupdesc.h.

ReleaseTupleDesc

#define ReleaseTupleDesc

(

tupdesc

)

Value:

    do { \
        if ((tupdesc)->tdrefcount >= 0) \
            DecrTupleDescRefCount(tupdesc); \
    } while (0)

Definition at line 122 of file tupdesc.h.

TupleDescAttr

#define TupleDescAttr	(		tupdesc,
			i
	)		(&(tupdesc)->attrs[(i)])

Definition at line 92 of file tupdesc.h.

TupleDescSize

#define TupleDescSize

(

src

)

Value:

    (offsetof(struct TupleDescData, attrs) + \
     (src)->natts * sizeof(FormData_pg_attribute))

Definition at line 102 of file tupdesc.h.

Typedef Documentation

AttrDefault

typedef struct AttrDefault AttrDefault

ConstrCheck

typedef struct ConstrCheck ConstrCheck

TupleConstr

typedef struct TupleConstr TupleConstr

TupleDesc

typedef struct TupleDescData* TupleDesc

Definition at line 89 of file tupdesc.h.

TupleDescData

typedef struct TupleDescData TupleDescData

Function Documentation

BuildDescForRelation()

TupleDesc BuildDescForRelation

(

List *

schema

)

Definition at line 786 of file tupdesc.c.

{
    int         natts;
    AttrNumber  attnum;
    ListCell   *l;
    TupleDesc   desc;
    bool        has_not_null;
    char       *attname;
    Oid         atttypid;
    int32       atttypmod;
    Oid         attcollation;
    int         attdim;
 
    /*
     * allocate a new tuple descriptor
     */
    natts = list_length(schema);
    desc = CreateTemplateTupleDesc(natts);
    has_not_null = false;
 
    attnum = 0;
 
    foreach(l, schema)
    {
        ColumnDef  *entry = lfirst(l);
        AclResult   aclresult;
        Form_pg_attribute att;
 
        /*
         * for each entry in the list, get the name and type information from
         * the list and have TupleDescInitEntry fill in the attribute
         * information we need.
         */
        attnum++;
 
        attname = entry->colname;
        typenameTypeIdAndMod(NULL, entry->typeName, &atttypid, &atttypmod);
 
        aclresult = object_aclcheck(TypeRelationId, atttypid, GetUserId(), ACL_USAGE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error_type(aclresult, atttypid);
 
        attcollation = GetColumnDefCollation(NULL, entry, atttypid);
        attdim = list_length(entry->typeName->arrayBounds);
 
        if (entry->typeName->setof)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                     errmsg("column \"%s\" cannot be declared SETOF",
                            attname)));
 
        TupleDescInitEntry(desc, attnum, attname,
                           atttypid, atttypmod, attdim);
        att = TupleDescAttr(desc, attnum - 1);
 
        /* Override TupleDescInitEntry's settings as requested */
        TupleDescInitEntryCollation(desc, attnum, attcollation);
        if (entry->storage)
            att->attstorage = entry->storage;
 
        /* Fill in additional stuff not handled by TupleDescInitEntry */
        att->attnotnull = entry->is_not_null;
        has_not_null |= entry->is_not_null;
        att->attislocal = entry->is_local;
        att->attinhcount = entry->inhcount;
    }
 
    if (has_not_null)
    {
        TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
 
        constr->has_not_null = true;
        constr->has_generated_stored = false;
        constr->defval = NULL;
        constr->missing = NULL;
        constr->num_defval = 0;
        constr->check = NULL;
        constr->num_check = 0;
        desc->constr = constr;
    }
    else
    {
        desc->constr = NULL;
    }
 
    return desc;
}

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, TypeName::arrayBounds, attname, attnum, TupleConstr::check, ColumnDef::colname, TupleDescData::constr, CreateTemplateTupleDesc(), TupleConstr::defval, ereport, errcode(), errmsg(), ERROR, GetColumnDefCollation(), GetUserId(), TupleConstr::has_generated_stored, TupleConstr::has_not_null, ColumnDef::inhcount, ColumnDef::is_local, ColumnDef::is_not_null, lfirst, list_length(), TupleConstr::missing, TupleConstr::num_check, TupleConstr::num_defval, object_aclcheck(), palloc0(), TypeName::setof, ColumnDef::storage, TupleDescAttr, TupleDescInitEntry(), TupleDescInitEntryCollation(), ColumnDef::typeName, and typenameTypeIdAndMod().

Referenced by DefineRelation(), and DefineVirtualRelation().

BuildDescFromLists()

TupleDesc BuildDescFromLists	(	List *	names,
		List *	types,
		List *	typmods,
		List *	collations
	)

Definition at line 886 of file tupdesc.c.

{
    int         natts;
    AttrNumber  attnum;
    ListCell   *l1;
    ListCell   *l2;
    ListCell   *l3;
    ListCell   *l4;
    TupleDesc   desc;
 
    natts = list_length(names);
    Assert(natts == list_length(types));
    Assert(natts == list_length(typmods));
    Assert(natts == list_length(collations));
 
    /*
     * allocate a new tuple descriptor
     */
    desc = CreateTemplateTupleDesc(natts);
 
    attnum = 0;
    forfour(l1, names, l2, types, l3, typmods, l4, collations)
    {
        char       *attname = strVal(lfirst(l1));
        Oid         atttypid = lfirst_oid(l2);
        int32       atttypmod = lfirst_int(l3);
        Oid         attcollation = lfirst_oid(l4);
 
        attnum++;
 
        TupleDescInitEntry(desc, attnum, attname, atttypid, atttypmod, 0);
        TupleDescInitEntryCollation(desc, attnum, attcollation);
    }
 
    return desc;
}

References Assert(), attname, attnum, CreateTemplateTupleDesc(), forfour, lfirst, lfirst_int, lfirst_oid, list_length(), strVal, TupleDescInitEntry(), TupleDescInitEntryCollation(), and types.

Referenced by ExecInitFunctionScan(), ExecInitTableFuncScan(), and inline_set_returning_function().

CreateTemplateTupleDesc()

TupleDesc CreateTemplateTupleDesc

(

int

natts

)

Definition at line 45 of file tupdesc.c.

{
    TupleDesc   desc;
 
    /*
     * sanity checks
     */
    Assert(natts >= 0);
 
    /*
     * Allocate enough memory for the tuple descriptor, including the
     * attribute rows.
     *
     * Note: the attribute array stride is sizeof(FormData_pg_attribute),
     * since we declare the array elements as FormData_pg_attribute for
     * notational convenience.  However, we only guarantee that the first
     * ATTRIBUTE_FIXED_PART_SIZE bytes of each entry are valid; most code that
     * copies tupdesc entries around copies just that much.  In principle that
     * could be less due to trailing padding, although with the current
     * definition of pg_attribute there probably isn't any padding.
     */
    desc = (TupleDesc) palloc(offsetof(struct TupleDescData, attrs) +
                              natts * sizeof(FormData_pg_attribute));
 
    /*
     * Initialize other fields of the tupdesc.
     */
    desc->natts = natts;
    desc->constr = NULL;
    desc->tdtypeid = RECORDOID;
    desc->tdtypmod = -1;
    desc->tdrefcount = -1;      /* assume not reference-counted */
 
    return desc;
}

References Assert(), TupleDescData::constr, FormData_pg_attribute, TupleDescData::natts, palloc(), TupleDescData::tdrefcount, TupleDescData::tdtypeid, and TupleDescData::tdtypmod.

Referenced by aclexplode(), addRangeTableEntryForFunction(), AllocateRelationDesc(), brtuple_disk_tupdesc(), build_function_result_tupdesc_d(), build_row_from_vars(), BuildDescForRelation(), BuildDescFromLists(), BuildHardcodedDescriptor(), ConstructTupleDescriptor(), create_toast_table(), CreateReplicationSlot(), CreateTupleDesc(), CreateTupleDescCopy(), CreateTupleDescCopyConstr(), dblink_get_pkey(), ExecInitFunctionScan(), ExecMakeTableFunctionResult(), ExecTypeFromExprList(), ExecTypeFromTLInternal(), expandRecordVariable(), ExplainResultDesc(), formrdesc(), get_expr_result_type(), GetPGVariableResultDesc(), gistrescan(), IdentifySystem(), init_sexpr(), initGinState(), libpqrcv_processTuples(), load_relcache_init_file(), materializeResult(), ordered_set_startup(), pg_buffercache_pages(), pg_get_publication_tables(), pg_lock_status(), pg_logdir_ls_internal(), pg_prepared_xact(), pg_stat_file(), pg_stat_get_archiver(), pg_stat_get_backend_subxact(), pg_stat_get_replication_slot(), pg_stat_get_subscription_stats(), pg_stat_get_wal(), pg_visibility_tupdesc(), pg_walfile_name_offset(), ReadReplicationSlot(), SendTablespaceList(), SendTimeLineHistory(), SendXlogRecPtrResult(), show_all_settings(), ShowAllGUCConfig(), ShowGUCConfigOption(), StartReplication(), test_predtest(), tsvector_unnest(), and TypeGetTupleDesc().

CreateTupleDesc()

TupleDesc CreateTupleDesc	(	int	natts,
		Form_pg_attribute *	attrs
	)

Definition at line 90 of file tupdesc.c.

{
    TupleDesc   desc;
    int         i;
 
    desc = CreateTemplateTupleDesc(natts);
 
    for (i = 0; i < natts; ++i)
        memcpy(TupleDescAttr(desc, i), attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
 
    return desc;
}

References ATTRIBUTE_FIXED_PART_SIZE, CreateTemplateTupleDesc(), i, and TupleDescAttr.

Referenced by AddNewAttributeTuples(), ATExecAddColumn(), and InsertOneTuple().

CreateTupleDescCopy()

TupleDesc CreateTupleDescCopy

(

TupleDesc

tupdesc

)

Definition at line 111 of file tupdesc.c.

{
    TupleDesc   desc;
    int         i;
 
    desc = CreateTemplateTupleDesc(tupdesc->natts);
 
    /* Flat-copy the attribute array */
    memcpy(TupleDescAttr(desc, 0),
           TupleDescAttr(tupdesc, 0),
           desc->natts * sizeof(FormData_pg_attribute));
 
    /*
     * Since we're not copying constraints and defaults, clear fields
     * associated with them.
     */
    for (i = 0; i < desc->natts; i++)
    {
        Form_pg_attribute att = TupleDescAttr(desc, i);
 
        att->attnotnull = false;
        att->atthasdef = false;
        att->atthasmissing = false;
        att->attidentity = '\0';
        att->attgenerated = '\0';
    }
 
    /* We can copy the tuple type identification, too */
    desc->tdtypeid = tupdesc->tdtypeid;
    desc->tdtypmod = tupdesc->tdtypmod;
 
    return desc;
}

References CreateTemplateTupleDesc(), FormData_pg_attribute, i, TupleDescData::natts, TupleDescData::tdtypeid, TupleDescData::tdtypmod, and TupleDescAttr.

Referenced by assign_record_type_typmod(), BuildTupleHashTableExt(), connectby_text(), connectby_text_serial(), CopyCachedPlan(), crosstab(), crosstab_hash(), database_to_xmlschema_internal(), do_autovacuum(), ExecEvalWholeRowVar(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInsert(), ExecPrepareTuplestoreResult(), FetchPreparedStatementResultDesc(), fmgr_sql(), get_record_type_from_query(), get_tupdesc_for_join_scan_tuples(), GetAfterTriggersStoreSlot(), getSpGistTupleDesc(), init_sexpr(), init_tuple_slot(), InitMaterializedSRF(), make_expanded_record_from_exprecord(), make_expanded_record_from_tupdesc(), materializeResult(), PersistHoldablePortal(), plperl_return_next_internal(), plpgsql_exec_function(), pltcl_func_handler(), PLy_spi_execute_fetch_result(), populate_recordset_worker(), RelationBuildLocalRelation(), RelationNameGetTupleDesc(), RevalidateCachedQuery(), schema_to_xmlschema_internal(), spi_dest_startup(), storeRow(), update_cached_tupdesc(), and UtilityTupleDescriptor().

CreateTupleDescCopyConstr()

TupleDesc CreateTupleDescCopyConstr

(

TupleDesc

tupdesc

)

Definition at line 151 of file tupdesc.c.

{
    TupleDesc   desc;
    TupleConstr *constr = tupdesc->constr;
    int         i;
 
    desc = CreateTemplateTupleDesc(tupdesc->natts);
 
    /* Flat-copy the attribute array */
    memcpy(TupleDescAttr(desc, 0),
           TupleDescAttr(tupdesc, 0),
           desc->natts * sizeof(FormData_pg_attribute));
 
    /* Copy the TupleConstr data structure, if any */
    if (constr)
    {
        TupleConstr *cpy = (TupleConstr *) palloc0(sizeof(TupleConstr));
 
        cpy->has_not_null = constr->has_not_null;
        cpy->has_generated_stored = constr->has_generated_stored;
 
        if ((cpy->num_defval = constr->num_defval) > 0)
        {
            cpy->defval = (AttrDefault *) palloc(cpy->num_defval * sizeof(AttrDefault));
            memcpy(cpy->defval, constr->defval, cpy->num_defval * sizeof(AttrDefault));
            for (i = cpy->num_defval - 1; i >= 0; i--)
                cpy->defval[i].adbin = pstrdup(constr->defval[i].adbin);
        }
 
        if (constr->missing)
        {
            cpy->missing = (AttrMissing *) palloc(tupdesc->natts * sizeof(AttrMissing));
            memcpy(cpy->missing, constr->missing, tupdesc->natts * sizeof(AttrMissing));
            for (i = tupdesc->natts - 1; i >= 0; i--)
            {
                if (constr->missing[i].am_present)
                {
                    Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
 
                    cpy->missing[i].am_value = datumCopy(constr->missing[i].am_value,
                                                         attr->attbyval,
                                                         attr->attlen);
                }
            }
        }
 
        if ((cpy->num_check = constr->num_check) > 0)
        {
            cpy->check = (ConstrCheck *) palloc(cpy->num_check * sizeof(ConstrCheck));
            memcpy(cpy->check, constr->check, cpy->num_check * sizeof(ConstrCheck));
            for (i = cpy->num_check - 1; i >= 0; i--)
            {
                cpy->check[i].ccname = pstrdup(constr->check[i].ccname);
                cpy->check[i].ccbin = pstrdup(constr->check[i].ccbin);
                cpy->check[i].ccvalid = constr->check[i].ccvalid;
                cpy->check[i].ccnoinherit = constr->check[i].ccnoinherit;
            }
        }
 
        desc->constr = cpy;
    }
 
    /* We can copy the tuple type identification, too */
    desc->tdtypeid = tupdesc->tdtypeid;
    desc->tdtypmod = tupdesc->tdtypmod;
 
    return desc;
}

References AttrDefault::adbin, AttrMissing::am_present, AttrMissing::am_value, ConstrCheck::ccbin, ConstrCheck::ccname, ConstrCheck::ccnoinherit, ConstrCheck::ccvalid, TupleConstr::check, TupleDescData::constr, CreateTemplateTupleDesc(), datumCopy(), TupleConstr::defval, FormData_pg_attribute, TupleConstr::has_generated_stored, TupleConstr::has_not_null, i, TupleConstr::missing, TupleDescData::natts, TupleConstr::num_check, TupleConstr::num_defval, palloc(), palloc0(), pstrdup(), TupleDescData::tdtypeid, TupleDescData::tdtypmod, and TupleDescAttr.

Referenced by ATGetQueueEntry(), CatalogCacheInitializeCache(), initGISTstate(), and lookup_rowtype_tupdesc_copy().

DecrTupleDescRefCount()

void DecrTupleDescRefCount

(

TupleDesc

tupdesc

)

Definition at line 384 of file tupdesc.c.

{
    Assert(tupdesc->tdrefcount > 0);
 
    ResourceOwnerForgetTupleDesc(CurrentResourceOwner, tupdesc);
    if (--tupdesc->tdrefcount == 0)
        FreeTupleDesc(tupdesc);
}

References Assert(), CurrentResourceOwner, FreeTupleDesc(), ResourceOwnerForgetTupleDesc(), and TupleDescData::tdrefcount.

Referenced by cache_record_field_properties(), ExecEvalConvertRowtype(), and ResourceOwnerReleaseInternal().

equalTupleDescs()

bool equalTupleDescs	(	TupleDesc	tupdesc1,
		TupleDesc	tupdesc2
	)

Definition at line 402 of file tupdesc.c.

{
    int         i,
                n;
 
    if (tupdesc1->natts != tupdesc2->natts)
        return false;
    if (tupdesc1->tdtypeid != tupdesc2->tdtypeid)
        return false;
 
    for (i = 0; i < tupdesc1->natts; i++)
    {
        Form_pg_attribute attr1 = TupleDescAttr(tupdesc1, i);
        Form_pg_attribute attr2 = TupleDescAttr(tupdesc2, i);
 
        /*
         * We do not need to check every single field here: we can disregard
         * attrelid and attnum (which were used to place the row in the attrs
         * array in the first place).  It might look like we could dispense
         * with checking attlen/attbyval/attalign, since these are derived
         * from atttypid; but in the case of dropped columns we must check
         * them (since atttypid will be zero for all dropped columns) and in
         * general it seems safer to check them always.
         *
         * attcacheoff must NOT be checked since it's possibly not set in both
         * copies.  We also intentionally ignore atthasmissing, since that's
         * not very relevant in tupdescs, which lack the attmissingval field.
         */
        if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0)
            return false;
        if (attr1->atttypid != attr2->atttypid)
            return false;
        if (attr1->attstattarget != attr2->attstattarget)
            return false;
        if (attr1->attlen != attr2->attlen)
            return false;
        if (attr1->attndims != attr2->attndims)
            return false;
        if (attr1->atttypmod != attr2->atttypmod)
            return false;
        if (attr1->attbyval != attr2->attbyval)
            return false;
        if (attr1->attalign != attr2->attalign)
            return false;
        if (attr1->attstorage != attr2->attstorage)
            return false;
        if (attr1->attcompression != attr2->attcompression)
            return false;
        if (attr1->attnotnull != attr2->attnotnull)
            return false;
        if (attr1->atthasdef != attr2->atthasdef)
            return false;
        if (attr1->attidentity != attr2->attidentity)
            return false;
        if (attr1->attgenerated != attr2->attgenerated)
            return false;
        if (attr1->attisdropped != attr2->attisdropped)
            return false;
        if (attr1->attislocal != attr2->attislocal)
            return false;
        if (attr1->attinhcount != attr2->attinhcount)
            return false;
        if (attr1->attcollation != attr2->attcollation)
            return false;
        /* variable-length fields are not even present... */
    }
 
    if (tupdesc1->constr != NULL)
    {
        TupleConstr *constr1 = tupdesc1->constr;
        TupleConstr *constr2 = tupdesc2->constr;
 
        if (constr2 == NULL)
            return false;
        if (constr1->has_not_null != constr2->has_not_null)
            return false;
        if (constr1->has_generated_stored != constr2->has_generated_stored)
            return false;
        n = constr1->num_defval;
        if (n != (int) constr2->num_defval)
            return false;
        /* We assume here that both AttrDefault arrays are in adnum order */
        for (i = 0; i < n; i++)
        {
            AttrDefault *defval1 = constr1->defval + i;
            AttrDefault *defval2 = constr2->defval + i;
 
            if (defval1->adnum != defval2->adnum)
                return false;
            if (strcmp(defval1->adbin, defval2->adbin) != 0)
                return false;
        }
        if (constr1->missing)
        {
            if (!constr2->missing)
                return false;
            for (i = 0; i < tupdesc1->natts; i++)
            {
                AttrMissing *missval1 = constr1->missing + i;
                AttrMissing *missval2 = constr2->missing + i;
 
                if (missval1->am_present != missval2->am_present)
                    return false;
                if (missval1->am_present)
                {
                    Form_pg_attribute missatt1 = TupleDescAttr(tupdesc1, i);
 
                    if (!datumIsEqual(missval1->am_value, missval2->am_value,
                                      missatt1->attbyval, missatt1->attlen))
                        return false;
                }
            }
        }
        else if (constr2->missing)
            return false;
        n = constr1->num_check;
        if (n != (int) constr2->num_check)
            return false;
 
        /*
         * Similarly, we rely here on the ConstrCheck entries being sorted by
         * name.  If there are duplicate names, the outcome of the comparison
         * is uncertain, but that should not happen.
         */
        for (i = 0; i < n; i++)
        {
            ConstrCheck *check1 = constr1->check + i;
            ConstrCheck *check2 = constr2->check + i;
 
            if (!(strcmp(check1->ccname, check2->ccname) == 0 &&
                  strcmp(check1->ccbin, check2->ccbin) == 0 &&
                  check1->ccvalid == check2->ccvalid &&
                  check1->ccnoinherit == check2->ccnoinherit))
                return false;
        }
    }
    else if (tupdesc2->constr != NULL)
        return false;
    return true;
}

References AttrDefault::adbin, AttrDefault::adnum, AttrMissing::am_present, AttrMissing::am_value, ConstrCheck::ccbin, ConstrCheck::ccname, ConstrCheck::ccnoinherit, ConstrCheck::ccvalid, TupleConstr::check, TupleDescData::constr, datumIsEqual(), TupleConstr::defval, TupleConstr::has_generated_stored, TupleConstr::has_not_null, i, TupleConstr::missing, NameStr, TupleDescData::natts, TupleConstr::num_check, TupleConstr::num_defval, TupleDescData::tdtypeid, and TupleDescAttr.

Referenced by acquire_inherited_sample_rows(), ProcedureCreate(), record_type_typmod_compare(), RelationClearRelation(), RelationFindReplTupleSeq(), RevalidateCachedQuery(), and shared_record_table_compare().

FreeTupleDesc()

void FreeTupleDesc

(

TupleDesc

tupdesc

)

Definition at line 309 of file tupdesc.c.

{
    int         i;
 
    /*
     * Possibly this should assert tdrefcount == 0, to disallow explicit
     * freeing of un-refcounted tupdescs?
     */
    Assert(tupdesc->tdrefcount <= 0);
 
    if (tupdesc->constr)
    {
        if (tupdesc->constr->num_defval > 0)
        {
            AttrDefault *attrdef = tupdesc->constr->defval;
 
            for (i = tupdesc->constr->num_defval - 1; i >= 0; i--)
                pfree(attrdef[i].adbin);
            pfree(attrdef);
        }
        if (tupdesc->constr->missing)
        {
            AttrMissing *attrmiss = tupdesc->constr->missing;
 
            for (i = tupdesc->natts - 1; i >= 0; i--)
            {
                if (attrmiss[i].am_present
                    && !TupleDescAttr(tupdesc, i)->attbyval)
                    pfree(DatumGetPointer(attrmiss[i].am_value));
            }
            pfree(attrmiss);
        }
        if (tupdesc->constr->num_check > 0)
        {
            ConstrCheck *check = tupdesc->constr->check;
 
            for (i = tupdesc->constr->num_check - 1; i >= 0; i--)
            {
                pfree(check[i].ccname);
                pfree(check[i].ccbin);
            }
            pfree(check);
        }
        pfree(tupdesc->constr);
    }
 
    pfree(tupdesc);
}

References Assert(), attbyval, TupleConstr::check, TupleDescData::constr, DatumGetPointer(), TupleConstr::defval, i, TupleConstr::missing, TupleDescData::natts, TupleConstr::num_check, TupleConstr::num_defval, pfree(), TupleDescData::tdrefcount, and TupleDescAttr.

Referenced by AddNewAttributeTuples(), AtEOXact_RelationCache(), DecrTupleDescRefCount(), ER_mc_callback(), ExecMakeTableFunctionResult(), ExecPrepareTuplestoreResult(), get_record_type_from_query(), ordered_set_startup(), PLy_result_dealloc(), RelationDestroyRelation(), RevalidateCachedQuery(), spgendscan(), TypeCacheRelCallback(), update_cached_tupdesc(), and walrcv_clear_result().

hashTupleDesc()

uint32 hashTupleDesc

(

TupleDesc

desc

)

Definition at line 554 of file tupdesc.c.

{
    uint32      s;
    int         i;
 
    s = hash_combine(0, hash_uint32(desc->natts));
    s = hash_combine(s, hash_uint32(desc->tdtypeid));
    for (i = 0; i < desc->natts; ++i)
        s = hash_combine(s, hash_uint32(TupleDescAttr(desc, i)->atttypid));
 
    return s;
}

References hash_combine(), hash_uint32(), i, TupleDescData::natts, TupleDescData::tdtypeid, and TupleDescAttr.

Referenced by record_type_typmod_hash(), and shared_record_table_hash().

IncrTupleDescRefCount()

void IncrTupleDescRefCount

(

TupleDesc

tupdesc

)

Definition at line 366 of file tupdesc.c.

{
    Assert(tupdesc->tdrefcount >= 0);
 
    ResourceOwnerEnlargeTupleDescs(CurrentResourceOwner);
    tupdesc->tdrefcount++;
    ResourceOwnerRememberTupleDesc(CurrentResourceOwner, tupdesc);
}

References Assert(), CurrentResourceOwner, ResourceOwnerEnlargeTupleDescs(), ResourceOwnerRememberTupleDesc(), and TupleDescData::tdrefcount.

Referenced by cache_record_field_properties(), and ExecEvalConvertRowtype().

TupleDescCopy()

void TupleDescCopy	(	TupleDesc	dst,
		TupleDesc	src
	)

Definition at line 229 of file tupdesc.c.

{
    int         i;
 
    /* Flat-copy the header and attribute array */
    memcpy(dst, src, TupleDescSize(src));
 
    /*
     * Since we're not copying constraints and defaults, clear fields
     * associated with them.
     */
    for (i = 0; i < dst->natts; i++)
    {
        Form_pg_attribute att = TupleDescAttr(dst, i);
 
        att->attnotnull = false;
        att->atthasdef = false;
        att->atthasmissing = false;
        att->attidentity = '\0';
        att->attgenerated = '\0';
    }
    dst->constr = NULL;
 
    /*
     * Also, assume the destination is not to be ref-counted.  (Copying the
     * source's refcount would be wrong in any case.)
     */
    dst->tdrefcount = -1;
}

References TupleDescData::constr, i, TupleDescData::natts, TupleDescData::tdrefcount, TupleDescAttr, and TupleDescSize.

Referenced by index_truncate_tuple(), and share_tupledesc().

TupleDescCopyEntry()

void TupleDescCopyEntry	(	TupleDesc	dst,
		AttrNumber	dstAttno,
		TupleDesc	src,
		AttrNumber	srcAttno
	)

Definition at line 267 of file tupdesc.c.

{
    Form_pg_attribute dstAtt = TupleDescAttr(dst, dstAttno - 1);
    Form_pg_attribute srcAtt = TupleDescAttr(src, srcAttno - 1);
 
    /*
     * sanity checks
     */
    Assert(PointerIsValid(src));
    Assert(PointerIsValid(dst));
    Assert(srcAttno >= 1);
    Assert(srcAttno <= src->natts);
    Assert(dstAttno >= 1);
    Assert(dstAttno <= dst->natts);
 
    memcpy(dstAtt, srcAtt, ATTRIBUTE_FIXED_PART_SIZE);
 
    /*
     * Aside from updating the attno, we'd better reset attcacheoff.
     *
     * XXX Actually, to be entirely safe we'd need to reset the attcacheoff of
     * all following columns in dst as well.  Current usage scenarios don't
     * require that though, because all following columns will get initialized
     * by other uses of this function or TupleDescInitEntry.  So we cheat a
     * bit to avoid a useless O(N^2) penalty.
     */
    dstAtt->attnum = dstAttno;
    dstAtt->attcacheoff = -1;
 
    /* since we're not copying constraints or defaults, clear these */
    dstAtt->attnotnull = false;
    dstAtt->atthasdef = false;
    dstAtt->atthasmissing = false;
    dstAtt->attidentity = '\0';
    dstAtt->attgenerated = '\0';
}

References Assert(), ATTRIBUTE_FIXED_PART_SIZE, PointerIsValid, and TupleDescAttr.

Referenced by addRangeTableEntryForFunction(), ExecInitFunctionScan(), and ordered_set_startup().

TupleDescInitBuiltinEntry()

void TupleDescInitBuiltinEntry	(	TupleDesc	desc,
		AttrNumber	attributeNumber,
		const char *	attributeName,
		Oid	oidtypeid,
		int32	typmod,
		int	attdim
	)

Definition at line 657 of file tupdesc.c.

{
    Form_pg_attribute att;
 
    /* sanity checks */
    Assert(PointerIsValid(desc));
    Assert(attributeNumber >= 1);
    Assert(attributeNumber <= desc->natts);
 
    /* initialize the attribute fields */
    att = TupleDescAttr(desc, attributeNumber - 1);
    att->attrelid = 0;          /* dummy value */
 
    /* unlike TupleDescInitEntry, we require an attribute name */
    Assert(attributeName != NULL);
    namestrcpy(&(att->attname), attributeName);
 
    att->attstattarget = -1;
    att->attcacheoff = -1;
    att->atttypmod = typmod;
 
    att->attnum = attributeNumber;
    att->attndims = attdim;
 
    att->attnotnull = false;
    att->atthasdef = false;
    att->atthasmissing = false;
    att->attidentity = '\0';
    att->attgenerated = '\0';
    att->attisdropped = false;
    att->attislocal = true;
    att->attinhcount = 0;
    /* variable-length fields are not present in tupledescs */
 
    att->atttypid = oidtypeid;
 
    /*
     * Our goal here is to support just enough types to let basic builtin
     * commands work without catalog access - e.g. so that we can do certain
     * things even in processes that are not connected to a database.
     */
    switch (oidtypeid)
    {
        case TEXTOID:
        case TEXTARRAYOID:
            att->attlen = -1;
            att->attbyval = false;
            att->attalign = TYPALIGN_INT;
            att->attstorage = TYPSTORAGE_EXTENDED;
            att->attcompression = InvalidCompressionMethod;
            att->attcollation = DEFAULT_COLLATION_OID;
            break;
 
        case BOOLOID:
            att->attlen = 1;
            att->attbyval = true;
            att->attalign = TYPALIGN_CHAR;
            att->attstorage = TYPSTORAGE_PLAIN;
            att->attcompression = InvalidCompressionMethod;
            att->attcollation = InvalidOid;
            break;
 
        case INT4OID:
            att->attlen = 4;
            att->attbyval = true;
            att->attalign = TYPALIGN_INT;
            att->attstorage = TYPSTORAGE_PLAIN;
            att->attcompression = InvalidCompressionMethod;
            att->attcollation = InvalidOid;
            break;
 
        case INT8OID:
            att->attlen = 8;
            att->attbyval = FLOAT8PASSBYVAL;
            att->attalign = TYPALIGN_DOUBLE;
            att->attstorage = TYPSTORAGE_PLAIN;
            att->attcompression = InvalidCompressionMethod;
            att->attcollation = InvalidOid;
            break;
 
        case OIDOID:
            att->attlen = 4;
            att->attbyval = true;
            att->attalign = TYPALIGN_INT;
            att->attstorage = TYPSTORAGE_PLAIN;
            att->attcompression = InvalidCompressionMethod;
            att->attcollation = InvalidOid;
            break;
 
        default:
            elog(ERROR, "unsupported type %u", oidtypeid);
    }
}

References Assert(), elog(), ERROR, FLOAT8PASSBYVAL, InvalidCompressionMethod, InvalidOid, namestrcpy(), PointerIsValid, and TupleDescAttr.

Referenced by CreateReplicationSlot(), IdentifySystem(), ReadReplicationSlot(), SendTablespaceList(), SendTimeLineHistory(), SendXlogRecPtrResult(), ShowAllGUCConfig(), ShowGUCConfigOption(), and StartReplication().

TupleDescInitEntry()

void TupleDescInitEntry	(	TupleDesc	desc,
		AttrNumber	attributeNumber,
		const char *	attributeName,
		Oid	oidtypeid,
		int32	typmod,
		int	attdim
	)

Definition at line 583 of file tupdesc.c.

{
    HeapTuple   tuple;
    Form_pg_type typeForm;
    Form_pg_attribute att;
 
    /*
     * sanity checks
     */
    Assert(PointerIsValid(desc));
    Assert(attributeNumber >= 1);
    Assert(attributeNumber <= desc->natts);
 
    /*
     * initialize the attribute fields
     */
    att = TupleDescAttr(desc, attributeNumber - 1);
 
    att->attrelid = 0;          /* dummy value */
 
    /*
     * Note: attributeName can be NULL, because the planner doesn't always
     * fill in valid resname values in targetlists, particularly for resjunk
     * attributes. Also, do nothing if caller wants to re-use the old attname.
     */
    if (attributeName == NULL)
        MemSet(NameStr(att->attname), 0, NAMEDATALEN);
    else if (attributeName != NameStr(att->attname))
        namestrcpy(&(att->attname), attributeName);
 
    att->attstattarget = -1;
    att->attcacheoff = -1;
    att->atttypmod = typmod;
 
    att->attnum = attributeNumber;
    att->attndims = attdim;
 
    att->attnotnull = false;
    att->atthasdef = false;
    att->atthasmissing = false;
    att->attidentity = '\0';
    att->attgenerated = '\0';
    att->attisdropped = false;
    att->attislocal = true;
    att->attinhcount = 0;
    /* variable-length fields are not present in tupledescs */
 
    tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(oidtypeid));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for type %u", oidtypeid);
    typeForm = (Form_pg_type) GETSTRUCT(tuple);
 
    att->atttypid = oidtypeid;
    att->attlen = typeForm->typlen;
    att->attbyval = typeForm->typbyval;
    att->attalign = typeForm->typalign;
    att->attstorage = typeForm->typstorage;
    att->attcompression = InvalidCompressionMethod;
    att->attcollation = typeForm->typcollation;
 
    ReleaseSysCache(tuple);
}

References Assert(), elog(), ERROR, GETSTRUCT, HeapTupleIsValid, InvalidCompressionMethod, MemSet, NAMEDATALEN, NameStr, namestrcpy(), ObjectIdGetDatum(), PointerIsValid, ReleaseSysCache(), SearchSysCache1(), TupleDescAttr, and TYPEOID.

Referenced by aclexplode(), addRangeTableEntryForFunction(), brtuple_disk_tupdesc(), build_function_result_tupdesc_d(), build_row_from_vars(), BuildDescForRelation(), BuildDescFromLists(), create_toast_table(), dblink_get_pkey(), ExecInitFunctionScan(), ExecMakeTableFunctionResult(), ExecTypeFromExprList(), ExecTypeFromTLInternal(), expandRecordVariable(), ExplainResultDesc(), get_expr_result_type(), GetPGVariableResultDesc(), gistrescan(), init_sexpr(), initGinState(), libpqrcv_processTuples(), materializeResult(), ordered_set_startup(), pg_buffercache_pages(), pg_get_publication_tables(), pg_lock_status(), pg_logdir_ls_internal(), pg_prepared_xact(), pg_stat_file(), pg_stat_get_archiver(), pg_stat_get_backend_subxact(), pg_stat_get_replication_slot(), pg_stat_get_subscription_stats(), pg_stat_get_wal(), pg_visibility_tupdesc(), pg_walfile_name_offset(), resolve_polymorphic_tupdesc(), show_all_settings(), test_predtest(), tsvector_unnest(), and TypeGetTupleDesc().

TupleDescInitEntryCollation()

void TupleDescInitEntryCollation	(	TupleDesc	desc,
		AttrNumber	attributeNumber,
		Oid	collationid
	)

Definition at line 763 of file tupdesc.c.

{
    /*
     * sanity checks
     */
    Assert(PointerIsValid(desc));
    Assert(attributeNumber >= 1);
    Assert(attributeNumber <= desc->natts);
 
    TupleDescAttr(desc, attributeNumber - 1)->attcollation = collationid;
}

References Assert(), PointerIsValid, and TupleDescAttr.

Referenced by addRangeTableEntryForFunction(), build_row_from_vars(), BuildDescForRelation(), BuildDescFromLists(), ExecInitFunctionScan(), ExecTypeFromExprList(), ExecTypeFromTLInternal(), expandRecordVariable(), get_expr_result_type(), initGinState(), and resolve_polymorphic_tupdesc().