#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:

Data Structures
struct	attrDefault

struct	constrCheck

struct	tupleConstr

struct	tupleDesc

Macros
#define	PinTupleDesc(tupdesc)

#define	ReleaseTupleDesc(tupdesc)

Typedefs
typedef struct attrDefault	AttrDefault

typedef struct constrCheck	ConstrCheck

typedef struct tupleConstr	TupleConstr

typedef struct tupleDesc *	TupleDesc

Functions
TupleDesc	CreateTemplateTupleDesc (int natts, bool hasoid)

TupleDesc	CreateTupleDesc (int natts, bool hasoid, Form_pg_attribute *attrs)

TupleDesc	CreateTupleDescCopy (TupleDesc tupdesc)

TupleDesc	CreateTupleDescCopyConstr (TupleDesc tupdesc)

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)

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

#define PinTupleDesc ( tupdesc )

Value:

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

Definition at line 101 of file tupdesc.h.

Referenced by ExecSetSlotDescriptor().

#define ReleaseTupleDesc ( tupdesc )

Value:

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

Definition at line 107 of file tupdesc.h.

Referenced by coerce_record_to_complex(), composite_to_json(), composite_to_jsonb(), exec_move_row_from_datum(), exec_stmt_return(), exec_stmt_return_next(), ExecDropSingleTupleTableSlot(), ExecEvalWholeRowVar(), ExecResetTupleTable(), ExecSetSlotDescriptor(), get_cached_rowtype(), get_rule_expr(), GetAttributeByName(), GetAttributeByNum(), HeapTupleHeaderGetDatum(), hstore_from_record(), hstore_populate_record(), make_tuple_indirect(), pg_config(), plperl_hash_from_datum(), plperl_sv_to_datum(), pltcl_func_handler(), PLy_exec_function(), PLy_function_build_args(), PLyObject_ToComposite(), populate_composite(), populate_record_worker(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), record_in(), record_out(), record_recv(), record_send(), rowtype_field_matches(), and ShutdownTupleDescRef().

Typedef Documentation

typedef struct attrDefault AttrDefault

typedef struct constrCheck ConstrCheck

typedef struct tupleConstr TupleConstr

typedef struct tupleDesc * TupleDesc

Function Documentation

TupleDesc BuildDescForRelation ( List * schema )

Definition at line 681 of file tupdesc.c.

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, TypeName::arrayBounds, tupleDesc::attrs, tupleConstr::check, ColumnDef::colname, tupleDesc::constr, CreateTemplateTupleDesc(), tupleConstr::defval, ereport, errcode(), errmsg(), ERROR, GetColumnDefCollation(), GetUserId(), tupleConstr::has_not_null, ColumnDef::inhcount, ColumnDef::is_local, ColumnDef::is_not_null, lfirst, list_length(), tupleDesc::natts, NULL, tupleConstr::num_check, tupleConstr::num_defval, palloc0(), pg_type_aclcheck(), TypeName::setof, ColumnDef::storage, TupleDescInitEntry(), TupleDescInitEntryCollation(), ColumnDef::typeName, and typenameTypeIdAndMod().

Referenced by DefineRelation(), and DefineVirtualRelation().

 {
     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, false);
     has_not_null = false;
 
     attnum = 0;
 
     foreach(l, schema)
     {
         ColumnDef  *entry = lfirst(l);
         AclResult   aclresult;
 
         /*
          * 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 = pg_type_aclcheck(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);
 
         /* Override TupleDescInitEntry's settings as requested */
         TupleDescInitEntryCollation(desc, attnum, attcollation);
         if (entry->storage)
             desc->attrs[attnum - 1]->attstorage = entry->storage;
 
         /* Fill in additional stuff not handled by TupleDescInitEntry */
         desc->attrs[attnum - 1]->attnotnull = entry->is_not_null;
         has_not_null |= entry->is_not_null;
         desc->attrs[attnum - 1]->attislocal = entry->is_local;
         desc->attrs[attnum - 1]->attinhcount = entry->inhcount;
     }
 
     if (has_not_null)
     {
         TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
 
         constr->has_not_null = true;
         constr->defval = NULL;
         constr->num_defval = 0;
         constr->check = NULL;
         constr->num_check = 0;
         desc->constr = constr;
     }
     else
     {
         desc->constr = NULL;
     }
 
     return desc;
 }

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

Definition at line 777 of file tupdesc.c.

References Assert, CreateTemplateTupleDesc(), lfirst, lfirst_int, lfirst_oid, list_head(), list_length(), lnext, tupleDesc::natts, strVal, TupleDescInitEntry(), and TupleDescInitEntryCollation().

Referenced by ExecInitFunctionScan(), and ExecInitTableFuncScan().

 {
     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, false);
 
     attnum = 0;
 
     l2 = list_head(types);
     l3 = list_head(typmods);
     l4 = list_head(collations);
     foreach(l1, names)
     {
         char       *attname = strVal(lfirst(l1));
         Oid         atttypid;
         int32       atttypmod;
         Oid         attcollation;
 
         atttypid = lfirst_oid(l2);
         l2 = lnext(l2);
         atttypmod = lfirst_int(l3);
         l3 = lnext(l3);
         attcollation = lfirst_oid(l4);
         l4 = lnext(l4);
 
         attnum++;
 
         TupleDescInitEntry(desc, attnum, attname, atttypid, atttypmod, 0);
         TupleDescInitEntryCollation(desc, attnum, attcollation);
     }
 
     return desc;
 }

TupleDesc CreateTemplateTupleDesc	(	int	natts,
		bool	hasoid
	)

Definition at line 41 of file tupdesc.c.

References AssertArg, ATTRIBUTE_FIXED_PART_SIZE, tupleDesc::attrs, tupleDesc::constr, i, MAXALIGN, tupleDesc::natts, NULL, palloc(), RECORDOID, tupleDesc::tdhasoid, tupleDesc::tdrefcount, tupleDesc::tdtypeid, and tupleDesc::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(), CreateTupleDescCopy(), CreateTupleDescCopyConstr(), dblink_get_notify(), dblink_get_pkey(), ExecInitFunctionScan(), ExecMakeTableFunctionResult(), ExecTypeFromExprList(), ExecTypeFromTLInternal(), expandRecordVariable(), ExplainResultDesc(), formrdesc(), GetPGVariableResultDesc(), gistrescan(), IdentifySystem(), init_sexpr(), initGinState(), libpqrcv_processTuples(), load_relcache_init_file(), materializeQueryResult(), materializeResult(), ordered_set_startup(), pg_buffercache_pages(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_cursor(), pg_get_keywords(), pg_get_multixact_members(), pg_get_object_address(), pg_identify_object(), pg_identify_object_as_address(), pg_last_committed_xact(), pg_lock_status(), pg_logdir_ls(), pg_ls_dir_files(), pg_prepared_statement(), pg_prepared_xact(), pg_sequence_parameters(), pg_stat_file(), pg_stat_get_archiver(), pg_timezone_abbrevs(), pg_timezone_names(), pg_visibility_map_summary(), pg_visibility_tupdesc(), pg_walfile_name_offset(), prs_setup_firstcall(), show_all_file_settings(), show_all_settings(), ShowAllGUCConfig(), ShowGUCConfigOption(), StartReplication(), ts_setup_firstcall(), tsvector_unnest(), tt_setup_firstcall(), and TypeGetTupleDesc().

 {
     TupleDesc   desc;
     char       *stg;
     int         attroffset;
 
     /*
      * sanity checks
      */
     AssertArg(natts >= 0);
 
     /*
      * Allocate enough memory for the tuple descriptor, including the
      * attribute rows, and set up the attribute row pointers.
      *
      * Note: we assume that sizeof(struct tupleDesc) is a multiple of the
      * struct pointer alignment requirement, and hence we don't need to insert
      * alignment padding between the struct and the array of attribute row
      * pointers.
      *
      * Note: Only the fixed part of pg_attribute rows is included in tuple
      * descriptors, so we only need ATTRIBUTE_FIXED_PART_SIZE space per attr.
      * That might need alignment padding, however.
      */
     attroffset = sizeof(struct tupleDesc) + natts * sizeof(Form_pg_attribute);
     attroffset = MAXALIGN(attroffset);
     stg = palloc(attroffset + natts * MAXALIGN(ATTRIBUTE_FIXED_PART_SIZE));
     desc = (TupleDesc) stg;
 
     if (natts > 0)
     {
         Form_pg_attribute *attrs;
         int         i;
 
         attrs = (Form_pg_attribute *) (stg + sizeof(struct tupleDesc));
         desc->attrs = attrs;
         stg += attroffset;
         for (i = 0; i < natts; i++)
         {
             attrs[i] = (Form_pg_attribute) stg;
             stg += MAXALIGN(ATTRIBUTE_FIXED_PART_SIZE);
         }
     }
     else
         desc->attrs = NULL;
 
     /*
      * Initialize other fields of the tupdesc.
      */
     desc->natts = natts;
     desc->constr = NULL;
     desc->tdtypeid = RECORDOID;
     desc->tdtypmod = -1;
     desc->tdhasoid = hasoid;
     desc->tdrefcount = -1;      /* assume not reference-counted */
 
     return desc;
 }

TupleDesc CreateTupleDesc	(	int	natts,
		bool	hasoid,
		Form_pg_attribute *	attrs
	)

Definition at line 112 of file tupdesc.c.

References AssertArg, tupleDesc::attrs, tupleDesc::constr, tupleDesc::natts, NULL, palloc(), RECORDOID, tupleDesc::tdhasoid, tupleDesc::tdrefcount, tupleDesc::tdtypeid, and tupleDesc::tdtypmod.

Referenced by InsertOneTuple(), and TupleQueueHandleControlMessage().

 {
     TupleDesc   desc;
 
     /*
      * sanity checks
      */
     AssertArg(natts >= 0);
 
     desc = (TupleDesc) palloc(sizeof(struct tupleDesc));
     desc->attrs = attrs;
     desc->natts = natts;
     desc->constr = NULL;
     desc->tdtypeid = RECORDOID;
     desc->tdtypmod = -1;
     desc->tdhasoid = hasoid;
     desc->tdrefcount = -1;      /* assume not reference-counted */
 
     return desc;
 }

TupleDesc CreateTupleDescCopy ( TupleDesc tupdesc )

Definition at line 141 of file tupdesc.c.

References ATTRIBUTE_FIXED_PART_SIZE, tupleDesc::attrs, CreateTemplateTupleDesc(), i, tupleDesc::natts, tupleDesc::tdhasoid, tupleDesc::tdtypeid, and tupleDesc::tdtypmod.

Referenced by assign_record_type_typmod(), ATGetQueueEntry(), build_row_from_class(), check_sql_fn_retval(), connectby_text(), connectby_text_serial(), CopyCachedPlan(), crosstab(), crosstab_hash(), database_to_xmlschema_internal(), deflist_to_tuplestore(), do_autovacuum(), each_worker(), each_worker_jsonb(), elements_worker(), elements_worker_jsonb(), exec_move_row(), exec_stmt_return(), ExecEvalWholeRowVar(), ExecInitFunctionScan(), ExecPrepareTuplestoreResult(), FetchPreparedStatementResultDesc(), fmgr_sql(), init_sexpr(), LookupTupleHashEntry(), materializeResult(), PersistHoldablePortal(), pg_config(), plperl_return_next_internal(), plpgsql_exec_function(), pltcl_func_handler(), PLy_spi_execute_fetch_result(), populate_composite(), populate_recordset_worker(), RelationBuildLocalRelation(), RelationNameGetTupleDesc(), RevalidateCachedQuery(), schema_to_xmlschema_internal(), spi_dest_startup(), storeRow(), TQExamineRecord(), TQRemapRecord(), UtilityTupleDescriptor(), and xpath_table().

 {
     TupleDesc   desc;
     int         i;
 
     desc = CreateTemplateTupleDesc(tupdesc->natts, tupdesc->tdhasoid);
 
     for (i = 0; i < desc->natts; i++)
     {
         memcpy(desc->attrs[i], tupdesc->attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
         desc->attrs[i]->attnotnull = false;
         desc->attrs[i]->atthasdef = false;
         desc->attrs[i]->attidentity = '\0';
     }
 
     desc->tdtypeid = tupdesc->tdtypeid;
     desc->tdtypmod = tupdesc->tdtypmod;
 
     return desc;
 }

TupleDesc CreateTupleDescCopyConstr ( TupleDesc tupdesc )

Definition at line 168 of file tupdesc.c.

References attrDefault::adbin, ATTRIBUTE_FIXED_PART_SIZE, tupleDesc::attrs, constrCheck::ccbin, constrCheck::ccname, constrCheck::ccnoinherit, constrCheck::ccvalid, tupleConstr::check, tupleDesc::constr, CreateTemplateTupleDesc(), tupleConstr::defval, tupleConstr::has_not_null, i, tupleDesc::natts, tupleConstr::num_check, tupleConstr::num_defval, palloc(), palloc0(), pstrdup(), tupleDesc::tdhasoid, tupleDesc::tdtypeid, and tupleDesc::tdtypmod.

Referenced by CatalogCacheInitializeCache(), lookup_rowtype_tupdesc_copy(), and tuple_data_split_internal().

 {
     TupleDesc   desc;
     TupleConstr *constr = tupdesc->constr;
     int         i;
 
     desc = CreateTemplateTupleDesc(tupdesc->natts, tupdesc->tdhasoid);
 
     for (i = 0; i < desc->natts; i++)
     {
         memcpy(desc->attrs[i], tupdesc->attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
     }
 
     if (constr)
     {
         TupleConstr *cpy = (TupleConstr *) palloc0(sizeof(TupleConstr));
 
         cpy->has_not_null = constr->has_not_null;
 
         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--)
             {
                 if (constr->defval[i].adbin)
                     cpy->defval[i].adbin = pstrdup(constr->defval[i].adbin);
             }
         }
 
         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--)
             {
                 if (constr->check[i].ccname)
                     cpy->check[i].ccname = pstrdup(constr->check[i].ccname);
                 if (constr->check[i].ccbin)
                     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;
     }
 
     desc->tdtypeid = tupdesc->tdtypeid;
     desc->tdtypmod = tupdesc->tdtypmod;
 
     return desc;
 }

void DecrTupleDescRefCount ( TupleDesc tupdesc )

Definition at line 336 of file tupdesc.c.

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

Referenced by ATExecAddOf(), cache_record_field_properties(), ExecInitExprRec(), ResourceOwnerReleaseInternal(), TQExamineRecord(), TQRemapRecord(), and transformOfType().

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

bool equalTupleDescs	(	TupleDesc	tupdesc1,
		TupleDesc	tupdesc2
	)

Definition at line 354 of file tupdesc.c.

References attrDefault::adbin, attrDefault::adnum, tupleDesc::attrs, constrCheck::ccbin, constrCheck::ccname, constrCheck::ccnoinherit, constrCheck::ccvalid, tupleConstr::check, tupleDesc::constr, tupleConstr::defval, tupleConstr::has_not_null, i, NameStr, tupleDesc::natts, NULL, tupleConstr::num_check, tupleConstr::num_defval, tupleDesc::tdhasoid, and tupleDesc::tdtypeid.

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

 {
     int         i,
                 j,
                 n;
 
     if (tupdesc1->natts != tupdesc2->natts)
         return false;
     if (tupdesc1->tdtypeid != tupdesc2->tdtypeid)
         return false;
     if (tupdesc1->tdhasoid != tupdesc2->tdhasoid)
         return false;
 
     for (i = 0; i < tupdesc1->natts; i++)
     {
         Form_pg_attribute attr1 = tupdesc1->attrs[i];
         Form_pg_attribute attr2 = tupdesc2->attrs[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.
          */
         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->attstorage != attr2->attstorage)
             return false;
         if (attr1->attalign != attr2->attalign)
             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->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;
         /* attacl, attoptions and attfdwoptions 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;
         n = constr1->num_defval;
         if (n != (int) constr2->num_defval)
             return false;
         for (i = 0; i < n; i++)
         {
             AttrDefault *defval1 = constr1->defval + i;
             AttrDefault *defval2 = constr2->defval;
 
             /*
              * We can't assume that the items are always read from the system
              * catalogs in the same order; so use the adnum field to identify
              * the matching item to compare.
              */
             for (j = 0; j < n; defval2++, j++)
             {
                 if (defval1->adnum == defval2->adnum)
                     break;
             }
             if (j >= n)
                 return false;
             if (strcmp(defval1->adbin, defval2->adbin) != 0)
                 return false;
         }
         n = constr1->num_check;
         if (n != (int) constr2->num_check)
             return false;
         for (i = 0; i < n; i++)
         {
             ConstrCheck *check1 = constr1->check + i;
             ConstrCheck *check2 = constr2->check;
 
             /*
              * Similarly, don't assume that the checks are always read in the
              * same order; match them up by name and contents. (The name
              * *should* be unique, but...)
              */
             for (j = 0; j < n; check2++, j++)
             {
                 if (strcmp(check1->ccname, check2->ccname) == 0 &&
                     strcmp(check1->ccbin, check2->ccbin) == 0 &&
                     check1->ccvalid == check2->ccvalid &&
                     check1->ccnoinherit == check2->ccnoinherit)
                     break;
             }
             if (j >= n)
                 return false;
         }
     }
     else if (tupdesc2->constr != NULL)
         return false;
     return true;
 }

void FreeTupleDesc ( TupleDesc tupdesc )

Definition at line 268 of file tupdesc.c.

References Assert, tupleConstr::check, tupleDesc::constr, tupleConstr::defval, i, tupleConstr::num_check, tupleConstr::num_defval, pfree(), and tupleDesc::tdrefcount.

Referenced by AtEOXact_RelationCache(), DecrTupleDescRefCount(), exec_move_row(), exec_stmt_block(), ExecMakeTableFunctionResult(), ExecPrepareTuplestoreResult(), ordered_set_startup(), PLy_result_dealloc(), populate_composite(), RelationDestroyRelation(), RevalidateCachedQuery(), TQExamineRecord(), TQRemapRecord(), TypeCacheRelCallback(), and walrcv_clear_result().

 {
     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--)
             {
                 if (attrdef[i].adbin)
                     pfree(attrdef[i].adbin);
             }
             pfree(attrdef);
         }
         if (tupdesc->constr->num_check > 0)
         {
             ConstrCheck *check = tupdesc->constr->check;
 
             for (i = tupdesc->constr->num_check - 1; i >= 0; i--)
             {
                 if (check[i].ccname)
                     pfree(check[i].ccname);
                 if (check[i].ccbin)
                     pfree(check[i].ccbin);
             }
             pfree(check);
         }
         pfree(tupdesc->constr);
     }
 
     pfree(tupdesc);
 }

void IncrTupleDescRefCount ( TupleDesc tupdesc )

Definition at line 318 of file tupdesc.c.

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

Referenced by cache_record_field_properties(), lookup_rowtype_tupdesc(), and lookup_rowtype_tupdesc_noerror().

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

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

Definition at line 230 of file tupdesc.c.

References AssertArg, ATTRIBUTE_FIXED_PART_SIZE, tupleDesc::attrs, tupleDesc::natts, and PointerIsValid.

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

 {
     /*
      * sanity checks
      */
     AssertArg(PointerIsValid(src));
     AssertArg(PointerIsValid(dst));
     AssertArg(srcAttno >= 1);
     AssertArg(srcAttno <= src->natts);
     AssertArg(dstAttno >= 1);
     AssertArg(dstAttno <= dst->natts);
 
     memcpy(dst->attrs[dstAttno - 1], src->attrs[srcAttno - 1],
            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.
      */
     dst->attrs[dstAttno - 1]->attnum = dstAttno;
     dst->attrs[dstAttno - 1]->attcacheoff = -1;
 
     /* since we're not copying constraints or defaults, clear these */
     dst->attrs[dstAttno - 1]->attnotnull = false;
     dst->attrs[dstAttno - 1]->atthasdef = false;
     dst->attrs[dstAttno - 1]->attidentity = '\0';
 }

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

Definition at line 568 of file tupdesc.c.

References Assert, AssertArg, tupleDesc::attrs, BOOLOID, DEFAULT_COLLATION_OID, INT4OID, INT8OID, InvalidOid, namestrcpy(), tupleDesc::natts, NULL, PointerIsValid, TEXTARRAYOID, and TEXTOID.

Referenced by CreateReplicationSlot(), IdentifySystem(), ShowAllGUCConfig(), ShowGUCConfigOption(), and StartReplication().

 {
     Form_pg_attribute att;
 
     /* sanity checks */
     AssertArg(PointerIsValid(desc));
     AssertArg(attributeNumber >= 1);
     AssertArg(attributeNumber <= desc->natts);
 
     /* initialize the attribute fields */
     att = desc->attrs[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->attidentity = '\0';
     att->attisdropped = false;
     att->attislocal = true;
     att->attinhcount = 0;
     /* attacl, attoptions and attfdwoptions 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 = 'i';
             att->attstorage = 'x';
             att->attcollation = DEFAULT_COLLATION_OID;
             break;
 
         case BOOLOID:
             att->attlen = 1;
             att->attbyval = true;
             att->attalign = 'c';
             att->attstorage = 'p';
             att->attcollation = InvalidOid;
             break;
 
         case INT4OID:
             att->attlen = 4;
             att->attbyval = true;
             att->attalign = 'i';
             att->attstorage = 'p';
             att->attcollation = InvalidOid;
             break;
 
         case INT8OID:
             att->attlen = 8;
             att->attbyval = FLOAT8PASSBYVAL;
             att->attalign = 'd';
             att->attstorage = 'p';
             att->attcollation = InvalidOid;
             break;
     }
 }

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

Definition at line 497 of file tupdesc.c.

References AssertArg, tupleDesc::attrs, elog, ERROR, GETSTRUCT, HeapTupleIsValid, MemSet, NAMEDATALEN, NameStr, namestrcpy(), tupleDesc::natts, NULL, ObjectIdGetDatum, PointerIsValid, ReleaseSysCache(), SearchSysCache1, 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_notify(), dblink_get_pkey(), ExecInitFunctionScan(), ExecMakeTableFunctionResult(), ExecTypeFromExprList(), ExecTypeFromTLInternal(), expandRecordVariable(), ExplainResultDesc(), GetPGVariableResultDesc(), gistrescan(), init_sexpr(), initGinState(), libpqrcv_processTuples(), materializeQueryResult(), materializeResult(), ordered_set_startup(), pg_buffercache_pages(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_cursor(), pg_get_keywords(), pg_get_multixact_members(), pg_get_object_address(), pg_identify_object(), pg_identify_object_as_address(), pg_last_committed_xact(), pg_lock_status(), pg_logdir_ls(), pg_ls_dir_files(), pg_prepared_statement(), pg_prepared_xact(), pg_sequence_parameters(), pg_stat_file(), pg_stat_get_archiver(), pg_timezone_abbrevs(), pg_timezone_names(), pg_visibility_map_summary(), pg_visibility_tupdesc(), pg_walfile_name_offset(), prs_setup_firstcall(), resolve_polymorphic_tupdesc(), show_all_file_settings(), show_all_settings(), ts_setup_firstcall(), tsvector_unnest(), tt_setup_firstcall(), and TypeGetTupleDesc().

 {
     HeapTuple   tuple;
     Form_pg_type typeForm;
     Form_pg_attribute att;
 
     /*
      * sanity checks
      */
     AssertArg(PointerIsValid(desc));
     AssertArg(attributeNumber >= 1);
     AssertArg(attributeNumber <= desc->natts);
 
     /*
      * initialize the attribute fields
      */
     att = desc->attrs[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->attidentity = '\0';
     att->attisdropped = false;
     att->attislocal = true;
     att->attinhcount = 0;
     /* attacl, attoptions and attfdwoptions 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->attcollation = typeForm->typcollation;
 
     ReleaseSysCache(tuple);
 }

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

Definition at line 656 of file tupdesc.c.

References AssertArg, tupleDesc::attrs, tupleDesc::natts, and PointerIsValid.

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

 {
     /*
      * sanity checks
      */
     AssertArg(PointerIsValid(desc));
     AssertArg(attributeNumber >= 1);
     AssertArg(attributeNumber <= desc->natts);
 
     desc->attrs[attributeNumber - 1]->attcollation = collationid;
 }

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation