#define VARLENA_ATT_IS_PACKABLE(att) \
((att)->attstorage != TYPSTORAGE_PLAIN)
-/* FormData_pg_attribute.attstorage != TYPSTORAGE_PLAIN and an attlen of -1 */
-#define COMPACT_ATTR_IS_PACKABLE(att) \
- ((att)->attlen == -1 && (att)->attispackable)
-
/*
* Setup for caching pass-by-ref missing attributes in a way that survives
* tupleDesc destruction.
getmissingattr(TupleDesc tupleDesc,
int attnum, bool *isnull)
{
- CompactAttribute *att;
+ Form_pg_attribute att;
Assert(attnum <= tupleDesc->natts);
Assert(attnum > 0);
- att = TupleDescCompactAttr(tupleDesc, attnum - 1);
+ att = TupleDescAttr(tupleDesc, attnum - 1);
if (att->atthasmissing)
{
for (i = 0; i < numberOfAttributes; i++)
{
Datum val;
- CompactAttribute *atti;
+ Form_pg_attribute atti;
if (isnull[i])
continue;
val = values[i];
- atti = TupleDescCompactAttr(tupleDesc, i);
+ atti = TupleDescAttr(tupleDesc, i);
- if (COMPACT_ATTR_IS_PACKABLE(atti) &&
+ if (ATT_IS_PACKABLE(atti) &&
VARATT_CAN_MAKE_SHORT(DatumGetPointer(val)))
{
/*
* Fill in either a data value or a bit in the null bitmask
*/
static inline void
-fill_val(CompactAttribute *att,
+fill_val(Form_pg_attribute att,
bits8 **bit,
int *bitmask,
char **dataP,
data_length = VARSIZE_SHORT(val);
memcpy(data, val, data_length);
}
- else if (att->attispackable && VARATT_CAN_MAKE_SHORT(val))
+ else if (VARLENA_ATT_IS_PACKABLE(att) &&
+ VARATT_CAN_MAKE_SHORT(val))
{
/* convert to short varlena -- no alignment */
data_length = VARATT_CONVERTED_SHORT_SIZE(val);
for (i = 0; i < numberOfAttributes; i++)
{
- CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, i);
+ Form_pg_attribute attr = TupleDescAttr(tupleDesc, i);
fill_val(attr,
bitP ? &bitP : NULL,
Assert(!tupleDesc || attnum <= tupleDesc->natts);
if (attnum > (int) HeapTupleHeaderGetNatts(tup->t_data))
{
- if (tupleDesc &&
- TupleDescCompactAttr(tupleDesc, attnum - 1)->atthasmissing)
+ if (tupleDesc && TupleDescAttr(tupleDesc, attnum - 1)->atthasmissing)
return false;
else
return true;
if (!slow)
{
- CompactAttribute *att;
+ Form_pg_attribute att;
/*
* If we get here, there are no nulls up to and including the target
* attribute. If we have a cached offset, we can use it.
*/
- att = TupleDescCompactAttr(tupleDesc, attnum);
+ att = TupleDescAttr(tupleDesc, attnum);
if (att->attcacheoff >= 0)
return fetchatt(att, tp + att->attcacheoff);
for (j = 0; j <= attnum; j++)
{
- if (TupleDescCompactAttr(tupleDesc, j)->attlen <= 0)
+ if (TupleDescAttr(tupleDesc, j)->attlen <= 0)
{
slow = true;
break;
* fixed-width columns, in hope of avoiding future visits to this
* routine.
*/
- TupleDescCompactAttr(tupleDesc, 0)->attcacheoff = 0;
+ TupleDescAttr(tupleDesc, 0)->attcacheoff = 0;
/* we might have set some offsets in the slow path previously */
- while (j < natts && TupleDescCompactAttr(tupleDesc, j)->attcacheoff > 0)
+ while (j < natts && TupleDescAttr(tupleDesc, j)->attcacheoff > 0)
j++;
- off = TupleDescCompactAttr(tupleDesc, j - 1)->attcacheoff +
- TupleDescCompactAttr(tupleDesc, j - 1)->attlen;
+ off = TupleDescAttr(tupleDesc, j - 1)->attcacheoff +
+ TupleDescAttr(tupleDesc, j - 1)->attlen;
for (; j < natts; j++)
{
- CompactAttribute *att = TupleDescCompactAttr(tupleDesc, j);
+ Form_pg_attribute att = TupleDescAttr(tupleDesc, j);
if (att->attlen <= 0)
break;
Assert(j > attnum);
- off = TupleDescCompactAttr(tupleDesc, attnum)->attcacheoff;
+ off = TupleDescAttr(tupleDesc, attnum)->attcacheoff;
}
else
{
off = 0;
for (i = 0;; i++) /* loop exit is at "break" */
{
- CompactAttribute *att = TupleDescCompactAttr(tupleDesc, i);
+ Form_pg_attribute att = TupleDescAttr(tupleDesc, i);
if (HeapTupleHasNulls(tup) && att_isnull(i, bp))
{
}
}
- return fetchatt(TupleDescCompactAttr(tupleDesc, attnum), tp + off);
+ return fetchatt(TupleDescAttr(tupleDesc, attnum), tp + off);
}
/* ----------------
{
if (attrmiss[attnum].am_present)
{
- CompactAttribute *att = TupleDescCompactAttr(tupleDesc, attnum);
+ Form_pg_attribute att = TupleDescAttr(tupleDesc, attnum);
targetDataLen = att_align_datum(targetDataLen,
att->attalign,
/* Now fill in the missing values */
for (attnum = sourceNatts; attnum < natts; attnum++)
{
- CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, attnum);
+
+ Form_pg_attribute attr = TupleDescAttr(tupleDesc, attnum);
if (attrmiss && attrmiss[attnum].am_present)
{
for (attnum = 0; attnum < natts; attnum++)
{
- CompactAttribute *thisatt = TupleDescCompactAttr(tupleDesc, attnum);
+ Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
if (hasnulls && att_isnull(attnum, bp))
{
if (!slow)
{
- CompactAttribute *att;
+ Form_pg_attribute att;
/*
* If we get here, there are no nulls up to and including the target
* attribute. If we have a cached offset, we can use it.
*/
- att = TupleDescCompactAttr(tupleDesc, attnum);
+ att = TupleDescAttr(tupleDesc, attnum);
if (att->attcacheoff >= 0)
return fetchatt(att, tp + att->attcacheoff);
for (j = 0; j <= attnum; j++)
{
- if (TupleDescCompactAttr(tupleDesc, j)->attlen <= 0)
+ if (TupleDescAttr(tupleDesc, j)->attlen <= 0)
{
slow = true;
break;
* fixed-width columns, in hope of avoiding future visits to this
* routine.
*/
- TupleDescCompactAttr(tupleDesc, 0)->attcacheoff = 0;
+ TupleDescAttr(tupleDesc, 0)->attcacheoff = 0;
/* we might have set some offsets in the slow path previously */
- while (j < natts && TupleDescCompactAttr(tupleDesc, j)->attcacheoff > 0)
+ while (j < natts && TupleDescAttr(tupleDesc, j)->attcacheoff > 0)
j++;
- off = TupleDescCompactAttr(tupleDesc, j - 1)->attcacheoff +
- TupleDescCompactAttr(tupleDesc, j - 1)->attlen;
+ off = TupleDescAttr(tupleDesc, j - 1)->attcacheoff +
+ TupleDescAttr(tupleDesc, j - 1)->attlen;
for (; j < natts; j++)
{
- CompactAttribute *att = TupleDescCompactAttr(tupleDesc, j);
+ Form_pg_attribute att = TupleDescAttr(tupleDesc, j);
if (att->attlen <= 0)
break;
Assert(j > attnum);
- off = TupleDescCompactAttr(tupleDesc, attnum)->attcacheoff;
+ off = TupleDescAttr(tupleDesc, attnum)->attcacheoff;
}
else
{
off = 0;
for (i = 0;; i++) /* loop exit is at "break" */
{
- CompactAttribute *att = TupleDescCompactAttr(tupleDesc, i);
+ Form_pg_attribute att = TupleDescAttr(tupleDesc, i);
if (IndexTupleHasNulls(tup) && att_isnull(i, bp))
{
}
}
- return fetchatt(TupleDescCompactAttr(tupleDesc, attnum), tp + off);
+ return fetchatt(TupleDescAttr(tupleDesc, attnum), tp + off);
}
/*
for (attnum = 0; attnum < natts; attnum++)
{
- CompactAttribute *thisatt = TupleDescCompactAttr(tupleDescriptor, attnum);
+ Form_pg_attribute thisatt = TupleDescAttr(tupleDescriptor, attnum);
if (hasnulls && att_isnull(attnum, bp))
{
return CopyIndexTuple(source);
/* Create temporary descriptor to scribble on */
- truncdesc = CreateTemplateTupleDesc(sourceDescriptor->natts);
+ truncdesc = palloc(TupleDescSize(sourceDescriptor));
TupleDescCopy(truncdesc, sourceDescriptor);
truncdesc->natts = leavenatts;
ResourceOwnerForget(owner, PointerGetDatum(tupdesc), &tupdesc_resowner_desc);
}
-/*
- * populate_compact_attribute
- * Fills in the corresponding CompactAttribute element from the
- * Form_pg_attribute for the given attribute number. This must be called
- * whenever a change is made to a Form_pg_attribute in the TupleDesc.
- */
-void
-populate_compact_attribute(TupleDesc tupdesc, int attnum)
-{
- Form_pg_attribute src = TupleDescAttr(tupdesc, attnum);
- CompactAttribute *dst = &tupdesc->compact_attrs[attnum];
-
- memset(dst, 0, sizeof(CompactAttribute));
-
- dst->attcacheoff = -1;
- dst->attlen = src->attlen;
-
- dst->attbyval = src->attbyval;
- dst->attispackable = (src->attstorage != TYPSTORAGE_PLAIN);
- dst->atthasmissing = src->atthasmissing;
- dst->attisdropped = src->attisdropped;
- dst->attgenerated = (src->attgenerated != '\0');
- dst->attnotnull = src->attnotnull;
-
- dst->attalign = src->attalign;
-}
-
/*
* CreateTemplateTupleDesc
* This function allocates an empty tuple descriptor structure.
Assert(natts >= 0);
/*
- * Allocate enough memory for the tuple descriptor, the CompactAttribute
- * array and also an array of the full FormData_pg_attribute data.
+ * Allocate enough memory for the tuple descriptor, including the
+ * attribute rows.
*
- * Note: the 'attrs' 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
+ * 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, compact_attrs) +
- natts * sizeof(CompactAttribute) +
+ desc = (TupleDesc) palloc(offsetof(struct TupleDescData, attrs) +
natts * sizeof(FormData_pg_attribute));
/*
desc->tdtypeid = RECORDOID;
desc->tdtypmod = -1;
desc->tdrefcount = -1; /* assume not reference-counted */
- desc->attrs = TupleDescAttrAddress(desc);
return desc;
}
desc = CreateTemplateTupleDesc(natts);
for (i = 0; i < natts; ++i)
- {
memcpy(TupleDescAttr(desc, i), attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
- populate_compact_attribute(desc, i);
- }
+
return desc;
}
att->atthasmissing = false;
att->attidentity = '\0';
att->attgenerated = '\0';
-
- populate_compact_attribute(desc, i);
}
/* We can copy the tuple type identification, too */
TupleDescAttr(tupdesc, 0),
desc->natts * sizeof(FormData_pg_attribute));
- for (i = 0; i < desc->natts; i++)
- populate_compact_attribute(desc, i);
-
/* Copy the TupleConstr data structure, if any */
if (constr)
{
{
if (constr->missing[i].am_present)
{
- CompactAttribute *attr = TupleDescCompactAttr(tupdesc, i);
+ Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
cpy->missing[i].am_value = datumCopy(constr->missing[i].am_value,
attr->attbyval,
{
int i;
- /* Flat-copy the header and attribute arrays */
+ /* Flat-copy the header and attribute array */
memcpy(dst, src, TupleDescSize(src));
- /*
- * Adjust 'attrs' to point to the dst FormData_pg_attribute array rather
- * than the src's.
- */
- dst->attrs = TupleDescAttrAddress(dst);
-
/*
* Since we're not copying constraints and defaults, clear fields
* associated with them.
att->atthasmissing = false;
att->attidentity = '\0';
att->attgenerated = '\0';
-
- populate_compact_attribute(dst, i);
}
dst->constr = NULL;
dstAtt->atthasmissing = false;
dstAtt->attidentity = '\0';
dstAtt->attgenerated = '\0';
-
- populate_compact_attribute(dst, dstAttno - 1);
}
/*
return false;
if (missval1->am_present)
{
- CompactAttribute *missatt1 = TupleDescCompactAttr(tupdesc1, i);
+ Form_pg_attribute missatt1 = TupleDescAttr(tupdesc1, i);
if (!datumIsEqual(missval1->am_value, missval2->am_value,
missatt1->attbyval, missatt1->attlen))
att->attcompression = InvalidCompressionMethod;
att->attcollation = typeForm->typcollation;
- populate_compact_attribute(desc, attributeNumber - 1);
-
ReleaseSysCache(tuple);
}
default:
elog(ERROR, "unsupported type %u", oidtypeid);
}
-
- populate_compact_attribute(desc, attributeNumber - 1);
}
/*
att->attcollation = InvalidOid;
/* In case we changed typlen, we'd better reset following offsets */
for (int i = spgFirstIncludeColumn; i < outTupDesc->natts; i++)
- TupleDescCompactAttr(outTupDesc, i)->attcacheoff = -1;
-
- populate_compact_attribute(outTupDesc, spgKeyColumn);
+ TupleDescAttr(outTupDesc, i)->attcacheoff = -1;
}
return outTupDesc;
}
ReleaseSysCache(tuple);
}
-
- populate_compact_attribute(indexTupDesc, i);
}
pfree(amroutine);
cookedDefaults = lappend(cookedDefaults, cooked);
attr->atthasdef = true;
}
-
- populate_compact_attribute(descriptor, attnum - 1);
}
/*
att->attstorage = entry->storage;
else if (entry->storage_name)
att->attstorage = GetAttributeStorage(att->atttypid, entry->storage_name);
-
- populate_compact_attribute(desc, attnum - 1);
}
return desc;
for (; attnum < natts; attnum++)
{
- CompactAttribute *thisatt = TupleDescCompactAttr(tupleDesc, attnum);
+ Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
if (hasnulls && att_isnull(attnum, bp))
{
*/
for (i = 0; i < natts; i++)
{
- if (!TupleDescCompactAttr(tupdesc, i)->attisdropped)
+ if (!TupleDescAttr(tupdesc, i)->attisdropped)
{
/* Non-dropped attributes */
dvalues[i] = InputFunctionCall(&attinmeta->attinfuncs[i],
attp,
ATTRIBUTE_FIXED_PART_SIZE);
- populate_compact_attribute(relation->rd_att, attnum - 1);
-
/* Update constraint/default info */
if (attp->attnotnull)
constr->has_not_null = true;
#endif
/*
- * We can easily set the attcacheoff value for the first attribute: it
- * must be zero. This eliminates the need for special cases for attnum=1
- * that used to exist in fastgetattr() and index_getattr().
+ * However, we can easily set the attcacheoff value for the first
+ * attribute: it must be zero. This eliminates the need for special cases
+ * for attnum=1 that used to exist in fastgetattr() and index_getattr().
*/
if (RelationGetNumberOfAttributes(relation) > 0)
- TupleDescCompactAttr(relation->rd_att, 0)->attcacheoff = 0;
+ TupleDescAttr(relation->rd_att, 0)->attcacheoff = 0;
/*
* Set up constraint/default info
has_not_null |= attrs[i].attnotnull;
/* make sure attcacheoff is valid */
TupleDescAttr(relation->rd_att, i)->attcacheoff = -1;
-
- populate_compact_attribute(relation->rd_att, i);
}
/* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
- TupleDescCompactAttr(relation->rd_att, 0)->attcacheoff = 0;
+ TupleDescAttr(relation->rd_att, 0)->attcacheoff = 0;
/* mark not-null status */
if (has_not_null)
datt->attgenerated = satt->attgenerated;
datt->attnotnull = satt->attnotnull;
has_not_null |= satt->attnotnull;
- populate_compact_attribute(rel->rd_att, i);
}
if (has_not_null)
memcpy(TupleDescAttr(result, i), &attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
/* make sure attcacheoff is valid */
TupleDescAttr(result, i)->attcacheoff = -1;
-
- populate_compact_attribute(result, i);
}
/* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
- TupleDescCompactAttr(result, 0)->attcacheoff = 0;
+ TupleDescAttr(result, 0)->attcacheoff = 0;
/* Note: we don't bother to set up a TupleConstr entry */
goto read_failed;
has_not_null |= attr->attnotnull;
-
- populate_compact_attribute(rel->rd_att, i);
}
/* next read the access method specific field */
TupleDesc t2;
if (k1->shared)
- {
t1 = (TupleDesc) dsa_get_address(area, k1->u.shared_tupdesc);
- t1->attrs = TupleDescAttrAddress(t1);
- }
else
t1 = k1->u.local_tupdesc;
if (k2->shared)
- {
t2 = (TupleDesc) dsa_get_address(area, k2->u.shared_tupdesc);
- t2->attrs = TupleDescAttrAddress(t2);
- }
else
t2 = k2->u.local_tupdesc;
TupleDesc t;
if (k->shared)
- {
t = (TupleDesc) dsa_get_address(area, k->u.shared_tupdesc);
- t->attrs = TupleDescAttrAddress(t);
- }
else
t = k->u.local_tupdesc;
tupdesc = (TupleDesc)
dsa_get_address(CurrentSession->area,
entry->shared_tupdesc);
- tupdesc->attrs = TupleDescAttrAddress(tupdesc);
Assert(typmod == tupdesc->tdtypmod);
/* We may need to extend the local RecordCacheArray. */
result = (TupleDesc)
dsa_get_address(CurrentSession->area,
record_table_entry->key.u.shared_tupdesc);
- result->attrs = TupleDescAttrAddress(result);
Assert(result->tdrefcount == -1);
return result;
result = (TupleDesc)
dsa_get_address(CurrentSession->area,
record_table_entry->key.u.shared_tupdesc);
- result->attrs = TupleDescAttrAddress(result);
Assert(result->tdrefcount == -1);
return result;
record_table_entry);
result = (TupleDesc)
dsa_get_address(CurrentSession->area, shared_dp);
- result->attrs = TupleDescAttrAddress(result);
Assert(result->tdrefcount == -1);
return result;
*isnull = false;
if (HeapTupleNoNulls(tup))
{
- CompactAttribute *att;
+ Form_pg_attribute att;
- att = TupleDescCompactAttr(tupleDesc, attnum - 1);
+ att = TupleDescAttr(tupleDesc, attnum - 1);
if (att->attcacheoff >= 0)
return fetchatt(att, (char *) tup->t_data + tup->t_data->t_hoff +
att->attcacheoff);
if (!IndexTupleHasNulls(tup))
{
- CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, attnum - 1);
-
- if (attr->attcacheoff >= 0)
+ if (TupleDescAttr(tupleDesc, attnum - 1)->attcacheoff >= 0)
{
- return fetchatt(attr,
- (char *) tup + IndexInfoFindDataOffset(tup->t_info) +
- attr->attcacheoff);
+ return fetchatt(TupleDescAttr(tupleDesc, attnum - 1),
+ (char *) tup + IndexInfoFindDataOffset(tup->t_info)
+ + TupleDescAttr(tupleDesc, attnum - 1)->attcacheoff);
}
else
return nocache_index_getattr(tup, attnum, tupleDesc);
bool has_generated_stored;
} TupleConstr;
-/*
- * CompactAttribute
- * Cut-down version of FormData_pg_attribute for faster access for tasks
- * such as tuple deformation. These values are populated using the
- * populate_compact_attribute function, which must be called directly
- * after the FormData_pg_attribute struct is populated or altered in any
- * way.
- *
- * Currently, this struct is 16 bytes. Any code changes which enlarge this
- * struct should be considered very carefully.
- *
- * Code which must access a TupleDesc's attribute data should always make use
- * of the CompactAttribute when the required fields are available there. It's
- * more efficient to access the memory in CompactAttribute due to it both
- * being a more compact representation of FormData_pg_attribute, but also
- * because accessing the FormData_pg_attribute requires an additional pointer
- * indirection through TupleDescData.attrs
- */
-typedef struct CompactAttribute
-{
- int32 attcacheoff; /* fixed offset into tuple, if known, or -1 */
- int16 attlen; /* attr len in bytes or -1 = varlen, -2 =
- * cstring */
- bool attbyval; /* as FormData_pg_attribute.attbyval */
- bool attispackable; /* FormData_pg_attribute.attstorage !=
- * TYPSTORAGE_PLAIN */
- bool atthasmissing; /* as FormData_pg_attribute.atthasmissing */
- bool attisdropped; /* as FormData_pg_attribute.attisdropped */
- bool attgenerated; /* FormData_pg_attribute.attgenerated != '\0' */
- bool attnotnull; /* as FormData_pg_attribute.attnotnull */
- char attalign; /* alignment requirement */
-} CompactAttribute;
-
/*
* This struct is passed around within the backend to describe the structure
* of tuples. For tuples coming from on-disk relations, the information is
* context and go away when the context is freed. We set the tdrefcount
* field of such a descriptor to -1, while reference-counted descriptors
* always have tdrefcount >= 0.
- *
- * The attrs field stores the fixed-sized portion of FormData_pg_attribute.
- * Because that struct is large, we also store a corresponding
- * CompactAttribute for each attribute in compact_attrs. compact_attrs is
- * stored inline with the struct. Because CompactAttribute is significantly
- * smaller than FormData_pg_attribute, code, especially performance-critical
- * code, should prioritize using the fields from the CompactAttribute over the
- * equivalent fields in FormData_pg_attribute whenever possible.
- *
- * Any code making changes manually to the fields in 'attrs' must subsequently
- * call populate_compact_attribute() to flush the changes out to the
- * corresponding 'compact_attrs' element.
*/
typedef struct TupleDescData
{
int tdrefcount; /* reference count, or -1 if not counting */
TupleConstr *constr; /* constraints, or NULL if none */
/* attrs[N] is the description of Attribute Number N+1 */
- FormData_pg_attribute *attrs;
- CompactAttribute compact_attrs[FLEXIBLE_ARRAY_MEMBER];
+ FormData_pg_attribute attrs[FLEXIBLE_ARRAY_MEMBER];
} TupleDescData;
typedef struct TupleDescData *TupleDesc;
-extern void populate_compact_attribute(TupleDesc tupdesc, int attnum);
-
-/* Accessor for the i'th FormData_pg_attribute of tupdesc. */
+/* Accessor for the i'th attribute of tupdesc. */
#define TupleDescAttr(tupdesc, i) (&(tupdesc)->attrs[(i)])
-/*
- * Accessor for the i'th CompactAttribute of tupdesc.
- */
-static inline CompactAttribute *
-TupleDescCompactAttr(TupleDesc tupdesc, int i)
-{
- CompactAttribute *cattr = &tupdesc->compact_attrs[i];
-#ifdef USE_ASSERT_CHECKING
- CompactAttribute snapshot;
-
- /*
- * In Assert enabled builds we verify that the CompactAttribute is
- * populated correctly. This helps find bugs in places such as ALTER
- * TABLE where code makes changes to the FormData_pg_attribute but forgets
- * to call populate_compact_attribute.
- */
-
- /*
- * Take a snapshot of how the CompactAttribute is now before calling
- * populate_compact_attribute to make it up-to-date with the
- * FormData_pg_attribute.
- */
- memcpy(&snapshot, cattr, sizeof(CompactAttribute));
-
- populate_compact_attribute(tupdesc, i);
-
- /* reset attcacheoff back to what it was */
- cattr->attcacheoff = snapshot.attcacheoff;
-
- /* Ensure the snapshot matches the freshly populated CompactAttribute */
- Assert(memcmp(&snapshot, cattr, sizeof(CompactAttribute)) == 0);
-#endif
-
- return cattr;
-}
-
-
extern TupleDesc CreateTemplateTupleDesc(int natts);
extern TupleDesc CreateTupleDesc(int natts, Form_pg_attribute *attrs);
extern TupleDesc CreateTupleDescCopyConstr(TupleDesc tupdesc);
#define TupleDescSize(src) \
- (offsetof(struct TupleDescData, compact_attrs) + \
- (src)->natts * sizeof(CompactAttribute) + \
+ (offsetof(struct TupleDescData, attrs) + \
(src)->natts * sizeof(FormData_pg_attribute))
-#define TupleDescAttrAddress(desc) \
- (Form_pg_attribute) ((char *) (desc) + \
- (offsetof(struct TupleDescData, compact_attrs) + \
- (desc)->natts * sizeof(CompactAttribute)))
-
extern void TupleDescCopy(TupleDesc dst, TupleDesc src);
extern void TupleDescCopyEntry(TupleDesc dst, AttrNumber dstAttno,
#ifndef TUPMACS_H
#define TUPMACS_H
-#include "access/tupdesc.h"
#include "catalog/pg_type_d.h" /* for TYPALIGN macros */
#ifndef FRONTEND
/*
- * Given a Form_pg_attribute or CompactAttribute and a pointer into a tuple's
- * data area, return the correct value or pointer.
+ * Given a Form_pg_attribute and a pointer into a tuple's data area,
+ * return the correct value or pointer.
*
* We return a Datum value in all cases. If the attribute has "byval" false,
* we return the same pointer into the tuple data area that we're passed.
CommitTimestampShared
CommonEntry
CommonTableExpr
-CompactAttribute
CompareScalarsContext
CompiledExprState
CompositeIOData
projects / postgresql.git / commitdiff