Introduce CompactAttribute array in TupleDesc

The new compact_attrs array stores a few select fields from
FormData_pg_attribute in a more compact way, using only 16 bytes per
column instead of the 104 bytes that FormData_pg_attribute uses.  Using
CompactAttribute allows performance-critical operations such as tuple
deformation to be performed without looking at the FormData_pg_attribute
element in TupleDesc which means fewer cacheline accesses.  With this
change, NAMEDATALEN could be increased with a much smaller negative impact
on performance.

For some workloads, tuple deformation can be the most CPU intensive part
of processing the query.  Some testing with 16 columns on a table
where the first column is variable length showed around a 10% increase in
transactions per second for an OLAP type query performing aggregation on
the 16th column.  However, in certain cases, the increases were much
higher, up to ~25% on one AMD Zen4 machine.

This also makes pg_attribute.attcacheoff redundant.  A follow-on commit
will remove it, thus shrinking the FormData_pg_attribute struct by 4
bytes.

Author: David Rowley
Discussion: https://postgr.es/m/CAApHDvrBztXP3yx=NKNmo3xwFAFhEdyPnvrDg3=M0RhDs+4vYw@mail.gmail.com
Reviewed-by: Andres Freund, Victor Yegorov

src/backend/access/common/heaptuple.c

@@ -83,6 +83,10 @@
 #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.
@@ -147,12 +151,12 @@ Datum
 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)
 	{
@@ -223,15 +227,15 @@ heap_compute_data_size(TupleDesc tupleDesc,
 	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)))
 		{
 			/*
@@ -268,7 +272,7 @@ heap_compute_data_size(TupleDesc tupleDesc,
  * 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,
@@ -349,8 +353,7 @@ fill_val(Form_pg_attribute att,
 			data_length = VARSIZE_SHORT(val);
 			memcpy(data, val, data_length);
 		}
-		else if (VARLENA_ATT_IS_PACKABLE(att) &&
+		else if (att->attispackable && VARATT_CAN_MAKE_SHORT(val))
-				 VARATT_CAN_MAKE_SHORT(val))
 		{
 			/* convert to short varlena -- no alignment */
 			data_length = VARATT_CONVERTED_SHORT_SIZE(val);
@@ -427,7 +430,7 @@ heap_fill_tuple(TupleDesc tupleDesc,
 
 	for (i = 0; i < numberOfAttributes; i++)
 	{
-		Form_pg_attribute attr = TupleDescAttr(tupleDesc, i);
+		CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, i);
 
 		fill_val(attr,
 				 bitP ? &bitP : NULL,
@@ -461,7 +464,8 @@ heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
 	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;
@@ -570,13 +574,13 @@ nocachegetattr(HeapTuple tup,
 
 	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);
 
@@ -591,7 +595,7 @@ nocachegetattr(HeapTuple tup,
 
 			for (j = 0; j <= attnum; j++)
 			{
-				if (TupleDescAttr(tupleDesc, j)->attlen <= 0)
+				if (TupleDescCompactAttr(tupleDesc, j)->attlen <= 0)
 				{
 					slow = true;
 					break;
@@ -614,18 +618,18 @@ nocachegetattr(HeapTuple tup,
 		 * 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 +
+		off = TupleDescCompactAttr(tupleDesc, j - 1)->attcacheoff +
-			TupleDescAttr(tupleDesc, j - 1)->attlen;
+			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;
@@ -639,7 +643,7 @@ nocachegetattr(HeapTuple tup,
 
 		Assert(j > attnum);
 
-		off = TupleDescAttr(tupleDesc, attnum)->attcacheoff;
+		off = TupleDescCompactAttr(tupleDesc, attnum)->attcacheoff;
 	}
 	else
 	{
@@ -659,7 +663,7 @@ nocachegetattr(HeapTuple tup,
 		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))
 			{
@@ -707,7 +711,7 @@ nocachegetattr(HeapTuple tup,
 		}
 	}
 
-	return fetchatt(TupleDescAttr(tupleDesc, attnum), tp + off);
+	return fetchatt(TupleDescCompactAttr(tupleDesc, attnum), tp + off);
 }
 
 /* ----------------
@@ -892,7 +896,7 @@ expand_tuple(HeapTuple *targetHeapTuple,
 		{
 			if (attrmiss[attnum].am_present)
 			{
-				Form_pg_attribute att = TupleDescAttr(tupleDesc, attnum);
+				CompactAttribute *att = TupleDescCompactAttr(tupleDesc, attnum);
 
 				targetDataLen = att_align_datum(targetDataLen,
 												att->attalign,
@@ -1020,8 +1024,7 @@ expand_tuple(HeapTuple *targetHeapTuple,
 	/* 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)
 		{
@@ -1370,7 +1373,7 @@ heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc,
 
 	for (attnum = 0; attnum < natts; attnum++)
 	{
-		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
+		CompactAttribute *thisatt = TupleDescCompactAttr(tupleDesc, attnum);
 
 		if (hasnulls && att_isnull(attnum, bp))
 		{

src/backend/access/common/indextuple.c

@@ -303,13 +303,13 @@ nocache_index_getattr(IndexTuple tup,
 
 	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);
 
@@ -324,7 +324,7 @@ nocache_index_getattr(IndexTuple tup,
 
 			for (j = 0; j <= attnum; j++)
 			{
-				if (TupleDescAttr(tupleDesc, j)->attlen <= 0)
+				if (TupleDescCompactAttr(tupleDesc, j)->attlen <= 0)
 				{
 					slow = true;
 					break;
@@ -347,18 +347,18 @@ nocache_index_getattr(IndexTuple tup,
 		 * 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 +
+		off = TupleDescCompactAttr(tupleDesc, j - 1)->attcacheoff +
-			TupleDescAttr(tupleDesc, j - 1)->attlen;
+			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;
@@ -372,7 +372,7 @@ nocache_index_getattr(IndexTuple tup,
 
 		Assert(j > attnum);
 
-		off = TupleDescAttr(tupleDesc, attnum)->attcacheoff;
+		off = TupleDescCompactAttr(tupleDesc, attnum)->attcacheoff;
 	}
 	else
 	{
@@ -392,7 +392,7 @@ nocache_index_getattr(IndexTuple tup,
 		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))
 			{
@@ -440,7 +440,7 @@ nocache_index_getattr(IndexTuple tup,
 		}
 	}
 
-	return fetchatt(TupleDescAttr(tupleDesc, attnum), tp + off);
+	return fetchatt(TupleDescCompactAttr(tupleDesc, attnum), tp + off);
 }
 
 /*
@@ -490,7 +490,7 @@ index_deform_tuple_internal(TupleDesc tupleDescriptor,
 
 	for (attnum = 0; attnum < natts; attnum++)
 	{
-		Form_pg_attribute thisatt = TupleDescAttr(tupleDescriptor, attnum);
+		CompactAttribute *thisatt = TupleDescCompactAttr(tupleDescriptor, attnum);
 
 		if (hasnulls && att_isnull(attnum, bp))
 		{
@@ -588,7 +588,7 @@ index_truncate_tuple(TupleDesc sourceDescriptor, IndexTuple source,
 		return CopyIndexTuple(source);
 
 	/* Create temporary descriptor to scribble on */
-	truncdesc = palloc(TupleDescSize(sourceDescriptor));
+	truncdesc = CreateTemplateTupleDesc(sourceDescriptor->natts);
 	TupleDescCopy(truncdesc, sourceDescriptor);
 	truncdesc->natts = leavenatts;
 

src/backend/access/common/tupdesc.c

@@ -56,6 +56,33 @@ ResourceOwnerForgetTupleDesc(ResourceOwner owner, TupleDesc tupdesc)
 	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.
@@ -74,18 +101,19 @@ CreateTemplateTupleDesc(int natts)
 	Assert(natts >= 0);
 
 	/*
-	 * Allocate enough memory for the tuple descriptor, including the
+	 * Allocate enough memory for the tuple descriptor, the CompactAttribute
-	 * attribute rows.
+	 * array and also an array of the full FormData_pg_attribute data.
 	 *
-	 * Note: the attribute array stride is sizeof(FormData_pg_attribute),
+	 * Note: the 'attrs' array stride is sizeof(FormData_pg_attribute), since
-	 * since we declare the array elements as FormData_pg_attribute for
+	 * we declare the array elements as FormData_pg_attribute for notational
-	 * notational convenience.  However, we only guarantee that the first
+	 * 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));
 
 	/*
@@ -96,6 +124,7 @@ CreateTemplateTupleDesc(int natts)
 	desc->tdtypeid = RECORDOID;
 	desc->tdtypmod = -1;
 	desc->tdrefcount = -1;		/* assume not reference-counted */
+	desc->attrs = TupleDescAttrAddress(desc);
 
 	return desc;
 }
@@ -117,8 +146,10 @@ CreateTupleDesc(int natts, Form_pg_attribute *attrs)
 	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;
 }
 
@@ -155,6 +186,8 @@ CreateTupleDescCopy(TupleDesc tupdesc)
 		att->atthasmissing = false;
 		att->attidentity = '\0';
 		att->attgenerated = '\0';
+
+		populate_compact_attribute(desc, i);
 	}
 
 	/* We can copy the tuple type identification, too */
@@ -183,6 +216,9 @@ CreateTupleDescCopyConstr(TupleDesc tupdesc)
 		   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)
 	{
@@ -207,7 +243,7 @@ CreateTupleDescCopyConstr(TupleDesc tupdesc)
 			{
 				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,
@@ -252,9 +288,15 @@ TupleDescCopy(TupleDesc dst, TupleDesc src)
 {
 	int			i;
 
-	/* Flat-copy the header and attribute array */
+	/* Flat-copy the header and attribute arrays */
 	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.
@@ -268,6 +310,8 @@ TupleDescCopy(TupleDesc dst, TupleDesc src)
 		att->atthasmissing = false;
 		att->attidentity = '\0';
 		att->attgenerated = '\0';
+
+		populate_compact_attribute(dst, i);
 	}
 	dst->constr = NULL;
 
@@ -322,6 +366,8 @@ TupleDescCopyEntry(TupleDesc dst, AttrNumber dstAttno,
 	dstAtt->atthasmissing = false;
 	dstAtt->attidentity = '\0';
 	dstAtt->attgenerated = '\0';
+
+	populate_compact_attribute(dst, dstAttno - 1);
 }
 
 /*
@@ -521,7 +567,7 @@ equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
 					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))
@@ -714,6 +760,8 @@ TupleDescInitEntry(TupleDesc desc,
 	att->attcompression = InvalidCompressionMethod;
 	att->attcollation = typeForm->typcollation;
 
+	populate_compact_attribute(desc, attributeNumber - 1);
+
 	ReleaseSysCache(tuple);
 }
 
@@ -821,6 +869,8 @@ TupleDescInitBuiltinEntry(TupleDesc desc,
 		default:
 			elog(ERROR, "unsupported type %u", oidtypeid);
 	}
+
+	populate_compact_attribute(desc, attributeNumber - 1);
 }
 
 /*

src/backend/access/spgist/spgutils.c

@@ -331,7 +331,9 @@ getSpGistTupleDesc(Relation index, SpGistTypeDesc *keyType)
 		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;
 }

src/backend/catalog/index.c

@@ -477,6 +477,8 @@ ConstructTupleDescriptor(Relation heapRelation,
 
 			ReleaseSysCache(tuple);
 		}
+
+		populate_compact_attribute(indexTupDesc, i);
 	}
 
 	pfree(amroutine);

src/backend/commands/tablecmds.c

@@ -980,6 +980,8 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
 			cookedDefaults = lappend(cookedDefaults, cooked);
 			attr->atthasdef = true;
 		}
+
+		populate_compact_attribute(descriptor, attnum - 1);
 	}
 
 	/*
@@ -1396,6 +1398,8 @@ BuildDescForRelation(const List *columns)
 			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;

src/backend/executor/execTuples.c

@@ -1044,7 +1044,7 @@ slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp,
 
 	for (; attnum < natts; attnum++)
 	{
-		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
+		CompactAttribute *thisatt = TupleDescCompactAttr(tupleDesc, attnum);
 
 		if (hasnulls && att_isnull(attnum, bp))
 		{
@@ -2237,7 +2237,7 @@ BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values)
 	 */
 	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],

src/backend/utils/cache/relcache.c

@@ -585,6 +585,8 @@ RelationBuildTupleDesc(Relation relation)
 			   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;
@@ -674,12 +676,12 @@ RelationBuildTupleDesc(Relation relation)
 #endif
 
 	/*
-	 * However, we can easily set the attcacheoff value for the first
+	 * We can easily set the attcacheoff value for the first attribute: it
-	 * attribute: it must be zero.  This eliminates the need for special cases
+	 * must be zero.  This eliminates the need for special cases for attnum=1
-	 * for attnum=1 that used to exist in fastgetattr() and index_getattr().
+	 * 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
@@ -1965,10 +1967,12 @@ formrdesc(const char *relationName, Oid relationReltype,
 		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)
@@ -3579,6 +3583,7 @@ RelationBuildLocalRelation(const char *relname,
 		datt->attgenerated = satt->attgenerated;
 		datt->attnotnull = satt->attnotnull;
 		has_not_null |= satt->attnotnull;
+		populate_compact_attribute(rel->rd_att, i);
 	}
 
 	if (has_not_null)
@@ -4399,10 +4404,12 @@ BuildHardcodedDescriptor(int natts, const FormData_pg_attribute *attrs)
 		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 */
 
@@ -6166,6 +6173,8 @@ load_relcache_init_file(bool shared)
 				goto read_failed;
 
 			has_not_null |= attr->attnotnull;
+
+			populate_compact_attribute(rel->rd_att, i);
 		}
 
 		/* next read the access method specific field */

src/backend/utils/cache/typcache.c

@@ -241,12 +241,18 @@ shared_record_table_compare(const void *a, const void *b, size_t size,
 	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;
 
@@ -264,7 +270,10 @@ shared_record_table_hash(const void *a, size_t size, void *arg)
 	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;
 
@@ -1867,6 +1876,7 @@ lookup_rowtype_tupdesc_internal(Oid type_id, int32 typmod, bool noError)
 					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. */
@@ -2953,6 +2963,7 @@ find_or_make_matching_shared_tupledesc(TupleDesc tupdesc)
 		result = (TupleDesc)
 			dsa_get_address(CurrentSession->area,
 							record_table_entry->key.u.shared_tupdesc);
+		result->attrs = TupleDescAttrAddress(result);
 		Assert(result->tdrefcount == -1);
 
 		return result;
@@ -3016,6 +3027,7 @@ find_or_make_matching_shared_tupledesc(TupleDesc tupdesc)
 		result = (TupleDesc)
 			dsa_get_address(CurrentSession->area,
 							record_table_entry->key.u.shared_tupdesc);
+		result->attrs = TupleDescAttrAddress(result);
 		Assert(result->tdrefcount == -1);
 
 		return result;
@@ -3028,6 +3040,7 @@ find_or_make_matching_shared_tupledesc(TupleDesc tupdesc)
 						record_table_entry);
 	result = (TupleDesc)
 		dsa_get_address(CurrentSession->area, shared_dp);
+	result->attrs = TupleDescAttrAddress(result);
 	Assert(result->tdrefcount == -1);
 
 	return result;

src/include/access/htup_details.h

@@ -758,9 +758,9 @@ fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
 	*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);

src/include/access/itup.h

@@ -124,11 +124,13 @@ index_getattr(IndexTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
 
 	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),
+			return fetchatt(attr,
-							(char *) tup + IndexInfoFindDataOffset(tup->t_info)
+							(char *) tup + IndexInfoFindDataOffset(tup->t_info) +
-							+ TupleDescAttr(tupleDesc, attnum - 1)->attcacheoff);
+							attr->attcacheoff);
 		}
 		else
 			return nocache_index_getattr(tup, attnum, tupleDesc);

src/include/access/tupdesc.h

@@ -45,6 +45,39 @@ typedef struct TupleConstr
 	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
@@ -75,6 +108,18 @@ typedef struct TupleConstr
  * 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
 {
@@ -84,13 +129,53 @@ 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[FLEXIBLE_ARRAY_MEMBER];
+	FormData_pg_attribute *attrs;
+	CompactAttribute compact_attrs[FLEXIBLE_ARRAY_MEMBER];
 }			TupleDescData;
 typedef struct TupleDescData *TupleDesc;
 
-/* Accessor for the i'th attribute of tupdesc. */
+extern void populate_compact_attribute(TupleDesc tupdesc, int attnum);
+
+/* Accessor for the i'th FormData_pg_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);
@@ -100,9 +185,15 @@ extern TupleDesc CreateTupleDescCopy(TupleDesc tupdesc);
 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))
 
+#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,

src/include/access/tupmacs.h

@@ -14,6 +14,7 @@
 #ifndef TUPMACS_H
 #define TUPMACS_H
 
+#include "access/tupdesc.h"
 #include "catalog/pg_type_d.h"	/* for TYPALIGN macros */
 
 
@@ -30,8 +31,8 @@ att_isnull(int ATT, const bits8 *BITS)
 
 #ifndef FRONTEND
 /*
- * Given a Form_pg_attribute and a pointer into a tuple's data area,
+ * Given a Form_pg_attribute or CompactAttribute and a pointer into a tuple's
- * return the correct value or pointer.
+ * 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.

src/tools/pgindent/typedefs.list

@@ -454,6 +454,7 @@ CommitTimestampEntry
 CommitTimestampShared
 CommonEntry
 CommonTableExpr
+CompactAttribute
 CompareScalarsContext
 CompiledExprState
 CompositeIOData