struct varlena *attr;
char *tp; /* pointer to the tuple data */
uint16 infomask;
- Form_pg_attribute thisatt;
+ CompactAttribute *thisatt;
struct varatt_external toast_pointer;
infomask = ctx->tuphdr->t_infomask;
- thisatt = TupleDescAttr(RelationGetDescr(ctx->rel), ctx->attnum);
+ thisatt = TupleDescCompactAttr(RelationGetDescr(ctx->rel), ctx->attnum);
tp = (char *) ctx->tuphdr + ctx->tuphdr->t_hoff;
}
else
{
- tupdesc = CreateTupleDescCopy(RelationGetDescr(indexRel));
- tupdesc->natts = IndexRelationGetNumberOfKeyAttributes(indexRel);
+ tupdesc = CreateTupleDescTruncatedCopy(RelationGetDescr(indexRel),
+ IndexRelationGetNumberOfKeyAttributes(indexRel));
printflags |= RULE_INDEXDEF_KEYS_ONLY;
}
for (i = 0; i < nattrs; i++)
{
- Form_pg_attribute attr;
+ CompactAttribute *attr;
bool is_null;
bytea *attr_data = NULL;
- attr = TupleDescAttr(tupdesc, i);
+ attr = TupleDescCompactAttr(tupdesc, i);
/*
* Tuple header can specify fewer attributes than tuple descriptor as
for (attnum = 1; attnum <= tupdesc->natts; attnum++)
{
- Form_pg_attribute attr = TupleDescAttr(tupdesc, attnum - 1);
+ CompactAttribute *attr = TupleDescCompactAttr(tupdesc, attnum - 1);
if (!attr->attisdropped)
targetAttrs = lappend_int(targetAttrs, attnum);
/* We transmit all columns that are defined in the foreign table. */
for (attnum = 1; attnum <= tupdesc->natts; attnum++)
{
- Form_pg_attribute attr = TupleDescAttr(tupdesc, attnum - 1);
+ CompactAttribute *attr = TupleDescCompactAttr(tupdesc, attnum - 1);
if (!attr->attisdropped)
targetAttrs = lappend_int(targetAttrs, attnum);
foreach(lc, fmstate->target_attrs)
{
int attnum = lfirst_int(lc);
- Form_pg_attribute attr = TupleDescAttr(tupdesc, attnum - 1);
+ CompactAttribute *attr = TupleDescCompactAttr(tupdesc, attnum - 1);
Datum value;
bool isnull;
Datum result;
bool new = false;
AttrNumber attno;
- Form_pg_attribute attr;
+ CompactAttribute *attr;
Assert(!isnull);
attno = column->bv_attno;
- attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1);
+ attr = TupleDescCompactAttr(bdesc->bd_tupdesc, attno - 1);
/*
* If the recorded value is null, copy the new value (which we know to be
BrinValues *col_b = (BrinValues *) PG_GETARG_POINTER(2);
Oid colloid = PG_GET_COLLATION();
AttrNumber attno;
- Form_pg_attribute attr;
+ CompactAttribute *attr;
FmgrInfo *finfo;
Datum result;
Assert(!col_a->bv_allnulls && !col_b->bv_allnulls);
attno = col_a->bv_attno;
- attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1);
+ attr = TupleDescCompactAttr(bdesc->bd_tupdesc, attno - 1);
/* If B includes empty elements, mark A similarly, if needed. */
if (!DatumGetBool(col_a->bv_values[INCLUSION_CONTAINS_EMPTY]) &&
datumno < brdesc->bd_info[attnum]->oi_nstored;
datumno++)
{
- Form_pg_attribute thisatt = TupleDescAttr(diskdsc, stored);
+ CompactAttribute *thisatt = TupleDescCompactAttr(diskdsc, stored);
if (thisatt->attlen == -1)
{
/* Check for unused input columns */
for (; j < indesc->natts; j++)
{
- if (TupleDescAttr(indesc, j)->attisdropped)
+ if (TupleDescCompactAttr(indesc, j)->attisdropped)
continue;
nincols++;
same = false; /* we'll complain below */
for (i = 0; i < attrMap->maplen; i++)
{
- Form_pg_attribute inatt = TupleDescAttr(indesc, i);
- Form_pg_attribute outatt = TupleDescAttr(outdesc, i);
+ CompactAttribute *inatt = TupleDescCompactAttr(indesc, i);
+ CompactAttribute *outatt;
/*
* If the input column has a missing attribute, we need a conversion.
if (attrMap->attnums[i] == (i + 1))
continue;
+ outatt = TupleDescCompactAttr(outdesc, i);
+
/*
* If it's a dropped column and the corresponding input column is also
* dropped, we don't need a conversion. However, attlen and attalign
#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)
{
- Form_pg_attribute att;
+ CompactAttribute *att;
Assert(attnum <= tupleDesc->natts);
Assert(attnum > 0);
- att = TupleDescAttr(tupleDesc, attnum - 1);
+ att = TupleDescCompactAttr(tupleDesc, attnum - 1);
if (att->atthasmissing)
{
for (i = 0; i < numberOfAttributes; i++)
{
Datum val;
- Form_pg_attribute atti;
+ CompactAttribute *atti;
if (isnull[i])
continue;
val = values[i];
- atti = TupleDescAttr(tupleDesc, i);
+ atti = TupleDescCompactAttr(tupleDesc, i);
- if (ATT_IS_PACKABLE(atti) &&
+ if (COMPACT_ATTR_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(Form_pg_attribute att,
+fill_val(CompactAttribute *att,
bits8 **bit,
int *bitmask,
char **dataP,
data_length = VARSIZE_SHORT(val);
memcpy(data, val, data_length);
}
- else if (VARLENA_ATT_IS_PACKABLE(att) &&
- VARATT_CAN_MAKE_SHORT(val))
+ else if (att->attispackable && VARATT_CAN_MAKE_SHORT(val))
{
/* convert to short varlena -- no alignment */
data_length = VARATT_CONVERTED_SHORT_SIZE(val);
for (i = 0; i < numberOfAttributes; i++)
{
- Form_pg_attribute attr = TupleDescAttr(tupleDesc, i);
+ CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, i);
fill_val(attr,
bitP ? &bitP : NULL,
Assert(!tupleDesc || attnum <= tupleDesc->natts);
if (attnum > (int) HeapTupleHeaderGetNatts(tup->t_data))
{
- if (tupleDesc && TupleDescAttr(tupleDesc, attnum - 1)->atthasmissing)
+ if (tupleDesc &&
+ TupleDescCompactAttr(tupleDesc, attnum - 1)->atthasmissing)
return false;
else
return true;
if (!slow)
{
- Form_pg_attribute att;
+ CompactAttribute *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 = TupleDescAttr(tupleDesc, attnum);
+ att = TupleDescCompactAttr(tupleDesc, attnum);
if (att->attcacheoff >= 0)
return fetchatt(att, tp + att->attcacheoff);
for (j = 0; j <= attnum; j++)
{
- if (TupleDescAttr(tupleDesc, j)->attlen <= 0)
+ if (TupleDescCompactAttr(tupleDesc, j)->attlen <= 0)
{
slow = true;
break;
* fixed-width columns, in hope of avoiding future visits to this
* routine.
*/
- TupleDescAttr(tupleDesc, 0)->attcacheoff = 0;
+ TupleDescCompactAttr(tupleDesc, 0)->attcacheoff = 0;
/* we might have set some offsets in the slow path previously */
- while (j < natts && TupleDescAttr(tupleDesc, j)->attcacheoff > 0)
+ while (j < natts && TupleDescCompactAttr(tupleDesc, j)->attcacheoff > 0)
j++;
- off = TupleDescAttr(tupleDesc, j - 1)->attcacheoff +
- TupleDescAttr(tupleDesc, j - 1)->attlen;
+ off = TupleDescCompactAttr(tupleDesc, j - 1)->attcacheoff +
+ TupleDescCompactAttr(tupleDesc, j - 1)->attlen;
for (; j < natts; j++)
{
- Form_pg_attribute att = TupleDescAttr(tupleDesc, j);
+ CompactAttribute *att = TupleDescCompactAttr(tupleDesc, j);
if (att->attlen <= 0)
break;
Assert(j > attnum);
- off = TupleDescAttr(tupleDesc, attnum)->attcacheoff;
+ off = TupleDescCompactAttr(tupleDesc, attnum)->attcacheoff;
}
else
{
off = 0;
for (i = 0;; i++) /* loop exit is at "break" */
{
- Form_pg_attribute att = TupleDescAttr(tupleDesc, i);
+ CompactAttribute *att = TupleDescCompactAttr(tupleDesc, i);
if (HeapTupleHasNulls(tup) && att_isnull(i, bp))
{
}
}
- return fetchatt(TupleDescAttr(tupleDesc, attnum), tp + off);
+ return fetchatt(TupleDescCompactAttr(tupleDesc, attnum), tp + off);
}
/* ----------------
{
if (attrmiss[attnum].am_present)
{
- Form_pg_attribute att = TupleDescAttr(tupleDesc, attnum);
+ CompactAttribute *att = TupleDescCompactAttr(tupleDesc, attnum);
targetDataLen = att_align_datum(targetDataLen,
att->attalign,
/* Now fill in the missing values */
for (attnum = sourceNatts; attnum < natts; attnum++)
{
-
- Form_pg_attribute attr = TupleDescAttr(tupleDesc, attnum);
+ CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, attnum);
if (attrmiss && attrmiss[attnum].am_present)
{
for (attnum = 0; attnum < natts; attnum++)
{
- Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
+ CompactAttribute *thisatt = TupleDescCompactAttr(tupleDesc, attnum);
if (hasnulls && att_isnull(attnum, bp))
{
if (!slow)
{
- Form_pg_attribute att;
+ CompactAttribute *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 = TupleDescAttr(tupleDesc, attnum);
+ att = TupleDescCompactAttr(tupleDesc, attnum);
if (att->attcacheoff >= 0)
return fetchatt(att, tp + att->attcacheoff);
for (j = 0; j <= attnum; j++)
{
- if (TupleDescAttr(tupleDesc, j)->attlen <= 0)
+ if (TupleDescCompactAttr(tupleDesc, j)->attlen <= 0)
{
slow = true;
break;
* fixed-width columns, in hope of avoiding future visits to this
* routine.
*/
- TupleDescAttr(tupleDesc, 0)->attcacheoff = 0;
+ TupleDescCompactAttr(tupleDesc, 0)->attcacheoff = 0;
/* we might have set some offsets in the slow path previously */
- while (j < natts && TupleDescAttr(tupleDesc, j)->attcacheoff > 0)
+ while (j < natts && TupleDescCompactAttr(tupleDesc, j)->attcacheoff > 0)
j++;
- off = TupleDescAttr(tupleDesc, j - 1)->attcacheoff +
- TupleDescAttr(tupleDesc, j - 1)->attlen;
+ off = TupleDescCompactAttr(tupleDesc, j - 1)->attcacheoff +
+ TupleDescCompactAttr(tupleDesc, j - 1)->attlen;
for (; j < natts; j++)
{
- Form_pg_attribute att = TupleDescAttr(tupleDesc, j);
+ CompactAttribute *att = TupleDescCompactAttr(tupleDesc, j);
if (att->attlen <= 0)
break;
Assert(j > attnum);
- off = TupleDescAttr(tupleDesc, attnum)->attcacheoff;
+ off = TupleDescCompactAttr(tupleDesc, attnum)->attcacheoff;
}
else
{
off = 0;
for (i = 0;; i++) /* loop exit is at "break" */
{
- Form_pg_attribute att = TupleDescAttr(tupleDesc, i);
+ CompactAttribute *att = TupleDescCompactAttr(tupleDesc, i);
if (IndexTupleHasNulls(tup) && att_isnull(i, bp))
{
}
}
- return fetchatt(TupleDescAttr(tupleDesc, attnum), tp + off);
+ return fetchatt(TupleDescCompactAttr(tupleDesc, attnum), tp + off);
}
/*
for (attnum = 0; attnum < natts; attnum++)
{
- Form_pg_attribute thisatt = TupleDescAttr(tupleDescriptor, attnum);
+ CompactAttribute *thisatt = TupleDescCompactAttr(tupleDescriptor, attnum);
if (hasnulls && att_isnull(attnum, bp))
{
if (leavenatts == sourceDescriptor->natts)
return CopyIndexTuple(source);
- /* Create temporary descriptor to scribble on */
- truncdesc = palloc(TupleDescSize(sourceDescriptor));
- TupleDescCopy(truncdesc, sourceDescriptor);
- truncdesc->natts = leavenatts;
+ /* Create temporary truncated tuple descriptor */
+ truncdesc = CreateTupleDescTruncatedCopy(sourceDescriptor, leavenatts);
/* Deform, form copy of tuple with fewer attributes */
index_deform_tuple(source, truncdesc, values, isnull);
ResourceOwnerForget(owner, PointerGetDatum(tupdesc), &tupdesc_resowner_desc);
}
+/*
+ * populate_compact_attribute
+ * Fill 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, including the
- * attribute rows.
+ * Allocate enough memory for the tuple descriptor, the CompactAttribute
+ * array and also an array of FormData_pg_attribute.
*
- * 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.
+ * Note: the FormData_pg_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) +
+ desc = (TupleDesc) palloc(offsetof(struct TupleDescData, compact_attrs) +
+ natts * sizeof(CompactAttribute) +
natts * sizeof(FormData_pg_attribute));
/*
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 */
+ desc->tdtypeid = tupdesc->tdtypeid;
+ desc->tdtypmod = tupdesc->tdtypmod;
+
+ return desc;
+}
+
+/*
+ * CreateTupleDescTruncatedCopy
+ * This function creates a new TupleDesc with only the first 'natts'
+ * attributes from an existing TupleDesc
+ *
+ * !!! Constraints and defaults are not copied !!!
+ */
+TupleDesc
+CreateTupleDescTruncatedCopy(TupleDesc tupdesc, int natts)
+{
+ TupleDesc desc;
+ int i;
+
+ Assert(natts <= tupdesc->natts);
+
+ desc = CreateTemplateTupleDesc(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';
+
+ 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)
{
- Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
+ CompactAttribute *attr = TupleDescCompactAttr(tupdesc, i);
cpy->missing[i].am_value = datumCopy(constr->missing[i].am_value,
attr->attbyval,
{
int i;
- /* Flat-copy the header and attribute array */
+ /* Flat-copy the header and attribute arrays */
memcpy(dst, src, TupleDescSize(src));
/*
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)
{
- Form_pg_attribute missatt1 = TupleDescAttr(tupdesc1, i);
+ CompactAttribute *missatt1 = TupleDescCompactAttr(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);
}
/*
static Datum
getDatumCopy(BuildAccumulator *accum, OffsetNumber attnum, Datum value)
{
- Form_pg_attribute att;
+ CompactAttribute *att;
Datum res;
- att = TupleDescAttr(accum->ginstate->origTupdesc, attnum - 1);
+ att = TupleDescCompactAttr(accum->ginstate->origTupdesc, attnum - 1);
if (att->attbyval)
res = value;
else
GinScanEntry scanEntry, Snapshot snapshot)
{
OffsetNumber attnum;
- Form_pg_attribute attr;
+ CompactAttribute *attr;
/* Initialize empty bitmap result */
scanEntry->matchBitmap = tbm_create(work_mem * 1024L, NULL);
/* Locate tupdesc entry for key column (for attbyval/attlen data) */
attnum = scanEntry->attnum;
- attr = TupleDescAttr(btree->ginstate->origTupdesc, attnum - 1);
+ attr = TupleDescCompactAttr(btree->ginstate->origTupdesc, attnum - 1);
/*
* Predicate lock entry leaf page, following pages will be locked by
* tuples during page split. Also, B-tree is not adjusting tuples on
* internal pages the way GiST does.
*/
- giststate->nonLeafTupdesc = CreateTupleDescCopyConstr(index->rd_att);
- giststate->nonLeafTupdesc->natts =
- IndexRelationGetNumberOfKeyAttributes(index);
+ giststate->nonLeafTupdesc = CreateTupleDescTruncatedCopy(index->rd_att,
+ IndexRelationGetNumberOfKeyAttributes(index));
for (i = 0; i < IndexRelationGetNumberOfKeyAttributes(index); i++)
{
itupMinSize = (Size) MAXALIGN(sizeof(IndexTupleData));
for (i = 0; i < index->rd_att->natts; i++)
{
- if (TupleDescAttr(index->rd_att, i)->attlen < 0)
+ CompactAttribute *attr = TupleDescCompactAttr(index->rd_att, i);
+
+ if (attr->attlen < 0)
itupMinSize += VARHDRSZ;
else
- itupMinSize += TupleDescAttr(index->rd_att, i)->attlen;
+ itupMinSize += attr->attlen;
}
/* Calculate average and maximal number of index tuples which fit to page */
heap_attr_equals(TupleDesc tupdesc, int attrnum, Datum value1, Datum value2,
bool isnull1, bool isnull2)
{
- Form_pg_attribute att;
-
/*
* If one value is NULL and other is not, then they are certainly not
* equal
}
else
{
+ CompactAttribute *att;
+
Assert(attrnum <= tupdesc->natts);
- att = TupleDescAttr(tupdesc, attrnum - 1);
+ att = TupleDescCompactAttr(tupdesc, attrnum - 1);
return datumIsEqual(value1, value2, att->attbyval, att->attlen);
}
}
* that system attributes can't be stored externally.
*/
if (attrnum < 0 || isnull1 ||
- TupleDescAttr(tupdesc, attrnum - 1)->attlen != -1)
+ TupleDescCompactAttr(tupdesc, attrnum - 1)->attlen != -1)
continue;
/*
/* Be sure to null out any dropped columns */
for (i = 0; i < newTupDesc->natts; i++)
{
- if (TupleDescAttr(newTupDesc, i)->attisdropped)
+ if (TupleDescCompactAttr(newTupDesc, i)->attisdropped)
isnull[i] = true;
}
/*
* Look at non-null varlena attributes
*/
- if (!toast_isnull[i] && TupleDescAttr(tupleDesc, i)->attlen == -1)
+ if (!toast_isnull[i] && TupleDescCompactAttr(tupleDesc, i)->attlen == -1)
{
struct varlena *new_value;
*/
if (toast_isnull[i])
has_nulls = true;
- else if (TupleDescAttr(tupleDesc, i)->attlen == -1)
+ else if (TupleDescCompactAttr(tupleDesc, i)->attlen == -1)
{
struct varlena *new_value;
/*
* Look at non-null varlena attributes
*/
- if (!isnull[i] && TupleDescAttr(tupleDesc, i)->attlen == -1)
+ if (!isnull[i] && TupleDescCompactAttr(tupleDesc, i)->attlen == -1)
{
struct varlena *new_value;
datum2;
bool isNull1,
isNull2;
- Form_pg_attribute att;
+ CompactAttribute *att;
datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
- att = TupleDescAttr(itupdesc, attnum - 1);
+ att = TupleDescCompactAttr(itupdesc, attnum - 1);
if (isNull1 != isNull2)
break;
{
if (!isnulls[i])
{
- if (TupleDescAttr(leafDescriptor, i)->attlen == -1)
+ if (TupleDescCompactAttr(leafDescriptor, i)->attlen == -1)
leafDatums[i] = PointerGetDatum(PG_DETOAST_DATUM(datums[i]));
else
leafDatums[i] = datums[i];
att->attcollation = InvalidOid;
/* In case we changed typlen, we'd better reset following offsets */
for (int i = spgFirstIncludeColumn; i < outTupDesc->natts; i++)
- TupleDescAttr(outTupDesc, i)->attcacheoff = -1;
+ TupleDescCompactAttr(outTupDesc, i)->attcacheoff = -1;
+
+ populate_compact_attribute(outTupDesc, spgKeyColumn);
}
return outTupDesc;
}
for (i = 0; i < numAttrs; i++)
{
- if (TupleDescAttr(tupleDesc, i)->attlen == -1)
+ if (TupleDescCompactAttr(tupleDesc, i)->attlen == -1)
{
Datum value = values[i];
ReleaseSysCache(tuple);
}
+
+ populate_compact_attribute(indexTupDesc, i);
}
pfree(amroutine);
for (i = 0; i < attr_count; i++)
{
- if (TupleDescAttr(tupDesc, i)->attisdropped)
- continue;
- if (TupleDescAttr(tupDesc, i)->attgenerated)
+ CompactAttribute *attr = TupleDescCompactAttr(tupDesc, i);
+
+ if (attr->attisdropped || attr->attgenerated)
continue;
attnums = lappend_int(attnums, i + 1);
}
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 (int attnum = relDesc->natts; attnum > 0; attnum--)
{
- Form_pg_attribute attr = TupleDescAttr(relDesc, attnum - 1);
+ CompactAttribute *attr = TupleDescCompactAttr(relDesc, attnum - 1);
if (attr->attisdropped)
continue;
*/
for (int attnum = 1; attnum <= relDesc->natts; attnum++)
{
- Form_pg_attribute attr = TupleDescAttr(relDesc, attnum - 1);
+ CompactAttribute *attr = TupleDescCompactAttr(relDesc, attnum - 1);
if (attr->attisdropped)
{
for (int att = 1; att <= tupDesc->natts; att++)
{
/* ignore dropped columns */
- if (TupleDescAttr(tupDesc, att - 1)->attisdropped)
+ if (TupleDescCompactAttr(tupDesc, att - 1)->attisdropped)
continue;
if (heap_attisnull(&tmptup, att, tupDesc))
{
for (int i = 0; i < var_tupdesc->natts; i++)
{
- Form_pg_attribute vattr = TupleDescAttr(var_tupdesc, i);
- Form_pg_attribute sattr = TupleDescAttr(tupleDesc, i);
+ CompactAttribute *vattr = TupleDescCompactAttr(var_tupdesc, i);
+ CompactAttribute *sattr = TupleDescCompactAttr(tupleDesc, i);
if (!vattr->attisdropped)
continue; /* already checked non-dropped cols */
t = list_head(targetList);
for (i = 0; i < cleanLength; i++)
{
- if (TupleDescAttr(cleanTupType, i)->attisdropped)
+ if (TupleDescCompactAttr(cleanTupType, i)->attisdropped)
continue; /* map entry is already zero */
for (;;)
{
/* compute size of memory required */
for (int natt = 0; natt < desc->natts; natt++)
{
- Form_pg_attribute att = TupleDescAttr(desc, natt);
+ CompactAttribute *att = TupleDescCompactAttr(desc, natt);
Datum val;
if (att->attbyval || slot->tts_isnull[natt])
/* and copy all attributes into the pre-allocated space */
for (int natt = 0; natt < desc->natts; natt++)
{
- Form_pg_attribute att = TupleDescAttr(desc, natt);
+ CompactAttribute *att = TupleDescCompactAttr(desc, natt);
Datum val;
if (att->attbyval || slot->tts_isnull[natt])
for (; attnum < natts; attnum++)
{
- Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
+ CompactAttribute *thisatt = TupleDescCompactAttr(tupleDesc, attnum);
if (hasnulls && att_isnull(attnum, bp))
{
*/
for (i = 0; i < natts; i++)
{
- if (!TupleDescAttr(tupdesc, i)->attisdropped)
+ if (!TupleDescCompactAttr(tupdesc, i)->attisdropped)
{
/* Non-dropped attributes */
dvalues[i] = InputFunctionCall(&attinmeta->attinfuncs[i],
/* remaining columns in rettupdesc had better all be dropped */
for (colindex++; colindex <= tupnatts; colindex++)
{
- if (!TupleDescAttr(rettupdesc, colindex - 1)->attisdropped)
+ if (!TupleDescCompactAttr(rettupdesc, colindex - 1)->attisdropped)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("return type mismatch in function declared to return %s",
if (!pslot->tts_isnull[i]) /* treat nulls as having hash key 0 */
{
- Form_pg_attribute attr;
+ CompactAttribute *attr;
uint32 hkey;
- attr = TupleDescAttr(pslot->tts_tupleDescriptor, i);
+ attr = TupleDescCompactAttr(pslot->tts_tupleDescriptor, i);
hkey = datum_image_hash(pslot->tts_values[i], attr->attbyval, attr->attlen);
for (int i = 0; i < numkeys; i++)
{
- Form_pg_attribute attr;
+ CompactAttribute *attr;
if (tslot->tts_isnull[i] != pslot->tts_isnull[i])
{
continue;
/* perform binary comparison on the two datums */
- attr = TupleDescAttr(tslot->tts_tupleDescriptor, i);
+ attr = TupleDescCompactAttr(tslot->tts_tupleDescriptor, i);
if (!datum_image_eq(tslot->tts_values[i], pslot->tts_values[i],
attr->attbyval, attr->attlen))
{
for (int i = 0; i < natts; i++)
{
- Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
+ CompactAttribute *attr = TupleDescCompactAttr(tupdesc, i);
if (ri_GeneratedExprs[i])
{
Datum val;
bool isnull;
- Assert(attr->attgenerated == ATTRIBUTE_GENERATED_STORED);
+ Assert(TupleDescAttr(tupdesc, i)->attgenerated == ATTRIBUTE_GENERATED_STORED);
econtext->ecxt_scantuple = slot;
foreach(lc, exprstatelist)
{
ExprState *estate = (ExprState *) lfirst(lc);
- Form_pg_attribute attr = TupleDescAttr(slot->tts_tupleDescriptor,
- resind);
+ CompactAttribute *attr = TupleDescCompactAttr(slot->tts_tupleDescriptor,
+ resind);
values[resind] = ExecEvalExpr(estate,
econtext,
{
for (i = 0; i < natts; i++)
{
- Form_pg_attribute attr = TupleDescAttr(typeinfo, i);
+ CompactAttribute *attr = TupleDescCompactAttr(typeinfo, i);
if (attr->attisdropped)
continue;
for (i = 0; i < natts; i++)
{
Datum val = slot->tts_values[i];
- Form_pg_attribute attr = TupleDescAttr(typeinfo, i);
+ CompactAttribute *attr = TupleDescCompactAttr(typeinfo, i);
if (!attr->attisdropped && attr->attlen == -1 && !slot->tts_isnull[i])
{
*/
for (attnum = 0; attnum < desc->natts; attnum++)
{
- Form_pg_attribute att = TupleDescAttr(desc, attnum);
+ CompactAttribute *att = TupleDescCompactAttr(desc, attnum);
/*
* If the column is declared NOT NULL then it must be present in every
*/
for (attnum = 0; attnum < natts; attnum++)
{
- Form_pg_attribute att = TupleDescAttr(desc, attnum);
+ CompactAttribute *att = TupleDescCompactAttr(desc, attnum);
LLVMValueRef v_incby;
int alignto;
LLVMValueRef l_attno = l_int16_const(lc, attnum);
{
for (int i = 0; i < relation->rd_att->natts; i++)
{
- Form_pg_attribute attr = TupleDescAttr(relation->rd_att, i);
+ CompactAttribute *attr = TupleDescCompactAttr(relation->rd_att, i);
if (attr->attnotnull)
{
rel->notnullattnums = bms_add_member(rel->notnullattnums,
- attr->attnum);
+ i + 1);
/*
* Per RemoveAttributeById(), dropped columns will have their
*/
for (i = 0; i < desc->natts; i++)
{
- Form_pg_attribute att = TupleDescAttr(desc, i);
+ CompactAttribute *att = TupleDescCompactAttr(desc, i);
/*
* if the column in the new tuple or old tuple is null, nothing to do
{
for (i = 0; i < erh->nfields; i++)
{
- Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
+ CompactAttribute *attr = TupleDescCompactAttr(tupdesc, i);
if (!erh->dnulls[i] &&
!attr->attbyval && attr->attlen == -1 &&
bool check_constraints)
{
TupleDesc tupdesc;
- Form_pg_attribute attr;
+ CompactAttribute *attr;
Datum *dvalues;
bool *dnulls;
char *oldValue;
* Copy new field value into record's context, and deal with detoasting,
* if needed.
*/
- attr = TupleDescAttr(tupdesc, fnumber - 1);
+ attr = TupleDescCompactAttr(tupdesc, fnumber - 1);
if (!isnull && !attr->attbyval)
{
MemoryContext oldcxt;
for (fnumber = 0; fnumber < erh->nfields; fnumber++)
{
- Form_pg_attribute attr = TupleDescAttr(tupdesc, fnumber);
+ CompactAttribute *attr = TupleDescCompactAttr(tupdesc, fnumber);
Datum newValue;
bool isnull;
*/
if (!isnull)
{
- Form_pg_attribute attr = TupleDescAttr(erh->er_tupdesc, fnumber - 1);
+ CompactAttribute *attr = TupleDescCompactAttr(erh->er_tupdesc, fnumber - 1);
if (!attr->attbyval && attr->attlen == -1 &&
VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
* difference for ON UPDATE CASCADE, but for consistency we treat
* all changes to the PK the same.
*/
- Form_pg_attribute att = TupleDescAttr(oldslot->tts_tupleDescriptor, attnums[i] - 1);
+ CompactAttribute *att = TupleDescCompactAttr(oldslot->tts_tupleDescriptor, attnums[i] - 1);
if (!datum_image_eq(oldvalue, newvalue, att->attbyval, att->attlen))
return false;
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;
/*
* The attcacheoff values we read from pg_attribute should all be -1
- * ("unknown"). Verify this if assert checking is on. They will be
- * computed when and if needed during tuple access.
+ * ("unknown"). Verify this if assert checking is on.
*/
#ifdef USE_ASSERT_CHECKING
{
#endif
/*
- * 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().
+ * 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)
- TupleDescAttr(relation->rd_att, 0)->attcacheoff = 0;
+ TupleDescCompactAttr(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 */
- TupleDescAttr(relation->rd_att, 0)->attcacheoff = 0;
+ TupleDescCompactAttr(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 */
- TupleDescAttr(result, 0)->attcacheoff = 0;
+ TupleDescCompactAttr(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 */
*isnull = false;
if (HeapTupleNoNulls(tup))
{
- Form_pg_attribute att;
+ CompactAttribute *att;
- att = TupleDescAttr(tupleDesc, attnum - 1);
+ att = TupleDescCompactAttr(tupleDesc, attnum - 1);
if (att->attcacheoff >= 0)
return fetchatt(att, (char *) tup->t_data + tup->t_data->t_hoff +
att->attcacheoff);
if (!IndexTupleHasNulls(tup))
{
- if (TupleDescAttr(tupleDesc, attnum - 1)->attcacheoff >= 0)
+ CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, attnum - 1);
+
+ if (attr->attcacheoff >= 0)
{
- return fetchatt(TupleDescAttr(tupleDesc, attnum - 1),
- (char *) tup + IndexInfoFindDataOffset(tup->t_info)
- + TupleDescAttr(tupleDesc, attnum - 1)->attcacheoff);
+ return fetchatt(attr,
+ (char *) tup + IndexInfoFindDataOffset(tup->t_info) +
+ attr->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. The fields of this struct 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
+ * the fields of this struct when required fields are available here. It's
+ * more efficient to access the memory in CompactAttribute due to it being a
+ * more compact representation of FormData_pg_attribute and also because
+ * accessing the FormData_pg_attribute requires an additional calculations to
+ * obtain the base address of the array within the TupleDesc.
+ */
+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.
+ *
+ * Beyond the compact_attrs variable length array, the TupleDesc stores an
+ * array of FormData_pg_attribute. The TupleDescAttr() function, as defined
+ * below, takes care of calculating the address of the elements of the
+ * FormData_pg_attribute array.
+ *
+ * The array of CompactAttribute is effectively an abbreviated version of the
+ * array of FormData_pg_attribute. 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.
+ *
+ * Any code making changes manually to and fields in the FormData_pg_attribute
+ * array must subsequently call populate_compact_attribute() to flush the
+ * changes out to the corresponding 'compact_attrs' element.
*/
typedef struct TupleDescData
{
int32 tdtypmod; /* typmod for tuple type */
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[FLEXIBLE_ARRAY_MEMBER];
+ /* compact_attrs[N] is the compact metadata of Attribute Number N+1 */
+ CompactAttribute compact_attrs[FLEXIBLE_ARRAY_MEMBER];
} TupleDescData;
typedef struct TupleDescData *TupleDesc;
-/* Accessor for the i'th attribute of tupdesc. */
-#define TupleDescAttr(tupdesc, i) (&(tupdesc)->attrs[(i)])
+extern void populate_compact_attribute(TupleDesc tupdesc, int attnum);
+
+/*
+ * Calculates the base address of the Form_pg_attribute at the end of the
+ * TupleDescData struct.
+ */
+#define TupleDescAttrAddress(desc) \
+ (Form_pg_attribute) ((char *) (desc) + \
+ (offsetof(struct TupleDescData, compact_attrs) + \
+ (desc)->natts * sizeof(CompactAttribute)))
+
+/* Accessor for the i'th FormData_pg_attribute element of tupdesc. */
+static inline FormData_pg_attribute *
+TupleDescAttr(TupleDesc tupdesc, int i)
+{
+ FormData_pg_attribute *attrs = TupleDescAttrAddress(tupdesc);
+
+ return &attrs[i];
+}
+
+#undef TupleDescAttrAddress
+
+/*
+ * Accessor for the i'th CompactAttribute element 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 CreateTupleDescCopy(TupleDesc tupdesc);
+extern TupleDesc CreateTupleDescTruncatedCopy(TupleDesc tupdesc, int natts);
+
extern TupleDesc CreateTupleDescCopyConstr(TupleDesc tupdesc);
#define TupleDescSize(src) \
- (offsetof(struct TupleDescData, attrs) + \
+ (offsetof(struct TupleDescData, compact_attrs) + \
+ (src)->natts * sizeof(CompactAttribute) + \
(src)->natts * sizeof(FormData_pg_attribute))
extern void TupleDescCopy(TupleDesc dst, TupleDesc src);
#ifndef FRONTEND
/*
- * Given a Form_pg_attribute and a pointer into a tuple's data area,
- * return the correct value or pointer.
+ * Given an attbyval and an attlen from either a Form_pg_attribute or
+ * CompactAttribute 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.
- * Otherwise, we return the correct number of bytes fetched from the data
- * area and extended to Datum form.
+ * We return a Datum value in all cases. If attbyval is false, we return the
+ * same pointer into the tuple data area that we're passed. Otherwise, we
+ * return the correct number of bytes fetched from the data area and extended
+ * to Datum form.
*
* On machines where Datum is 8 bytes, we support fetching 8-byte byval
* attributes; otherwise, only 1, 2, and 4-byte values are supported.
CommitTimestampShared
CommonEntry
CommonTableExpr
+CompactAttribute
CompareScalarsContext
CompiledExprState
CompositeIOData
projects / users / c2main / postgres.git / commitdiff