Improving btree performance through specializing by key shape, take 2

Index: src/backend/access/nbtree/nbtutils_spec.h
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
--- a/src/backend/access/nbtree/nbtutils_spec.h	(revision b6e6b651af17cbf36192ab1f3f658968e94e172c)
+++ b/src/backend/access/nbtree/nbtutils_spec.h	(date 1649627408105)
@@ -667,6 +667,8 @@
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus

From 8cc1ea41353ba0d0d69a6383c75ed2663608d609 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 7 Apr 2022 12:30:00 +0200
Subject: [PATCH v2 2/7] Use specialized attribute iterators in
 backend/*/nbt*_spec.h

Split out for making it clear what substantial changes were made to the
pre-existing functions.

Even though not all nbt*_spec functions have been updated; most call sites
now can directly call the specialized functions instead of having to determine
the right specialization based on the (potentially locally unavailable) index
relation, making the specialization of those functions worth the effort.
---
 src/backend/access/nbtree/nbtsearch_spec.h | 16 +++---
 src/backend/access/nbtree/nbtsort_spec.h   | 24 +++++----
 src/backend/access/nbtree/nbtutils_spec.h  | 63 +++++++++++++---------
 3 files changed, 62 insertions(+), 41 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
index 73d5370496..a5c5f2b94f 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.h
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -823,6 +823,7 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -854,23 +855,26 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
diff --git a/src/backend/access/nbtree/nbtsort_spec.h b/src/backend/access/nbtree/nbtsort_spec.h
index 8f4a3602ca..d3f2db2dc4 100644
--- a/src/backend/access/nbtree/nbtsort_spec.h
+++ b/src/backend/access/nbtree/nbtsort_spec.h
@@ -27,8 +27,7 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -50,7 +49,7 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -82,22 +81,25 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 			}
 			else if (itup != NULL)
 			{
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 				int32		compare = 0;
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
index a4b934ae7a..638eff18f6 100644
--- a/src/backend/access/nbtree/nbtutils_spec.h
+++ b/src/backend/access/nbtree/nbtutils_spec.h
@@ -211,6 +211,8 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -222,20 +224,22 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -243,6 +247,7 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -295,7 +300,7 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -326,7 +331,10 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -337,27 +345,30 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -744,24 +755,28 @@ NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft,itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) !=
+			nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
-- 
2.30.2

From 7cd7335a8e0c0540835a738ad92dc6c214ebe566 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:51:01 +0200
Subject: [PATCH v2 5/7] Add a function whose task it is to populate all
 attcacheoff-s of a TupleDesc's attributes

It fills uncacheable offsets with -2; as opposed to -1 which signals
"unknown", thus allowing users of the API to determine the cache-ability
of an attribute at O(1) complexity after this one-time O(n) cost, as
opposed to the repeated O(n) cost that currently applies.
---
 src/backend/access/common/tupdesc.c | 97 +++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |  2 +
 2 files changed, 99 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 9f41b1e854..5630fc9da0 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -910,3 +910,100 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid value.
+ *
+ * Sets attcacheoff to -2 for uncacheable attributes (i.e. attributes after a
+ * variable length attributes).
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	i, j;
+
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+	{
+		/*
+		 * Already done the calculations, find the last attribute that has
+		 * cache offset.
+		 */
+		for (i = (AttrNumber) numberOfAttributes; i > 1; i--)
+		{
+			if (TupleDescAttr(desc, i - 1)->attcacheoff != -2)
+				return i;
+		}
+
+		return 1;
+	}
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	i = 1;
+	/*
+	 * Someone might have set some offsets previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (i < numberOfAttributes && TupleDescAttr(desc, i)->attcacheoff > 0)
+		i++;
+
+	/* Cache offset is undetermined. Start calculating offsets if possible */
+	if (i < numberOfAttributes &&
+		TupleDescAttr(desc, i)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, i - 1);
+		Size off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (i < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, i);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+						att->attcacheoff = off;
+					else
+						att->attcacheoff = -2;
+					i++;
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				i++;
+			}
+		} else {
+			if (off == att_align_nominal(off, att->attalign))
+				att->attcacheoff = off;
+			else
+				att->attcacheoff = -2;
+			i++;
+		}
+	}
+
+	/*
+	 * No cacheable offsets left. Fill the rest with -2s, but return the latest
+	 * cached offset.
+	 */
+	j = i;
+
+	while (i < numberOfAttributes)
+	{
+		TupleDescAttr(desc, i)->attcacheoff = -2;
+		i++;
+	}
+
+	return j;
+}
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index 28dd6de18b..219f837875 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.30.2

From eb05201ec8f207aec3c106813424477b9ab3c454 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:54:52 +0200
Subject: [PATCH v2 3/7] Specialize the nbtree rd_indam entry.

Because each rd_indam struct is seperately allocated for each index, we can
freely modify it at runtime without impacting other indexes of the same
access method. For btinsert (which effectively only calls _bt_insert) it is
useful to specialize that function, which also makes rd_indam->aminsert a
good signal whether or not the indexRelation has been fully optimized yet.
---
 src/backend/access/nbtree/nbtree.c    |  7 +++++++
 src/backend/access/nbtree/nbtsearch.c |  2 ++
 src/backend/access/nbtree/nbtsort.c   |  2 ++
 src/include/access/nbtree.h           | 14 ++++++++++++++
 4 files changed, 25 insertions(+)

diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 09c43eb226..95da2c46bf 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -161,6 +161,8 @@ btbuildempty(Relation index)
 	metapage = (Page) palloc(BLCKSZ);
 	_bt_initmetapage(metapage, P_NONE, 0, _bt_allequalimage(index, false));
 
+	nbt_opt_specialize(index);
+
 	/*
 	 * Write the page and log it.  It might seem that an immediate sync would
 	 * be sufficient to guarantee that the file exists on disk, but recovery
@@ -323,6 +325,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -765,6 +769,7 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 {
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
+	nbt_opt_specialize(info->index);
 
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
@@ -798,6 +803,8 @@ btvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
 	if (info->analyze_only)
 		return stats;
 
+	nbt_opt_specialize(info->index);
+
 	/*
 	 * If btbulkdelete was called, we need not do anything (we just maintain
 	 * the information used within _bt_vacuum_needs_cleanup() by calling
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index e81eee9c35..d5152bfcb7 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -181,6 +181,8 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
+	nbt_opt_specialize(scan->indexRelation);
+
 	pgstat_count_index_scan(rel);
 
 	/*
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index f1d146ba71..22c7163197 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -305,6 +305,8 @@ btbuild(Relation heap, Relation index, IndexInfo *indexInfo)
 	BTBuildState buildstate;
 	double		reltuples;
 
+	nbt_opt_specialize(index);
+
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
 		ResetUsage();
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 83e0dbab16..489b623663 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1132,6 +1132,19 @@ typedef struct BTOptions
 
 #ifdef NBTS_ENABLED
 
+/*
+ * Replace the functions in the rd_indam struct with a variant optimized for
+ * our key shape, if not already done.
+ *
+ * It only needs to be done once for every index relation loaded, so it's
+ * quite unlikely we need to do this and thus marked unlikely().
+ */
+#define nbt_opt_specialize(rel) \
+do { \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert)) \
+		_bt_specialize(rel); \
+} while (false)
+
 /*
  * Access a specialized nbtree function, based on the shape of the index key.
  */
@@ -1143,6 +1156,7 @@ typedef struct BTOptions
 
 #else /* not defined NBTS_ENABLED */
 
+#define nbt_opt_specialize(rel)
 #define NBT_SPECIALIZE_CALL(function, rel, ...) function(__VA_ARGS__)
 
 #endif /* NBTS_ENABLED */
-- 
2.30.2

From 38f619c26422ff8b58f6f70478ba110401f53ee0 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 7 Apr 2022 12:47:50 +0200
Subject: [PATCH v2 4/7] Optimize attribute iterator access for single-column
 btree keys

This removes the index_getattr_nocache call path, which has significant overhead.
---
 src/include/access/nbtree.h            |  9 ++++-
 src/include/access/nbtree_specialize.h | 56 ++++++++++++++++++++++++++
 2 files changed, 64 insertions(+), 1 deletion(-)

diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 489b623663..1559399b0e 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1120,6 +1120,7 @@ typedef struct BTOptions
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_COLUMN single
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 
@@ -1151,7 +1152,13 @@ do { \
 
 #define NBT_SPECIALIZE_CALL(function, rel, ...) \
 ( \
-	NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? (   \
+		NBTS_MAKE_NAME(function, NBTS_TYPE_SINGLE_COLUMN)(__VA_ARGS__) \
+	) \
+	: \
+	( \
+		NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+	) \
 )
 
 #else /* not defined NBTS_ENABLED */
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
index 23fdda4f0e..642bc4c795 100644
--- a/src/include/access/nbtree_specialize.h
+++ b/src/include/access/nbtree_specialize.h
@@ -79,6 +79,62 @@
 #define nbts_call_norel(name, rel, ...) \
 	(NBTS_FUNCTION(name)(__VA_ARGS__))
 
+/*
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path may never be used for indexes with multiple key
+ *  columns, because it does not ever continue to a next column.
+ */
+
+#define NBTS_SPECIALIZING_SINGLE_COLUMN
+#define NBTS_TYPE NBTS_TYPE_SINGLE_COLUMN
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) <= 1); \
+	for (int spec_i = 0; spec_i == 0 && (initAttNum) == 1 && (endAttNum) == 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+/*
+ * Simplified (optimized) variant of index_getattr specialized for extracting
+ * only the first attribute: cache offset is guaranteed to be 0, and as such
+ * no cache is required.
+ */
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	(IndexTupleHasNulls(itup) && att_isnull(0, (char *)(itup) + sizeof(IndexTupleData))) ? \
+	( \
+		(NBTS_MAKE_NAME(itup, isNull)) = true, \
+		(Datum)NULL \
+	) \
+	: \
+	( \
+		(NBTS_MAKE_NAME(itup, isNull) = false), \
+		(Datum) fetchatt(TupleDescAttr((tupDesc), 0), \
+		(char *) (itup) + IndexInfoFindDataOffset((itup)->t_info)) \
+	) \
+)
+
+#define nbts_attiter_curattisnull(tuple) \
+	NBTS_MAKE_NAME(tuple, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_COLUMN
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
  */
-- 
2.30.2

From 1ff81e78ae0cecbe2d46735b26e0fad049f45772 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Sun, 30 Jan 2022 16:23:31 +0100
Subject: [PATCH v2 1/7] Specialize nbtree functions on btree key shape

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, initially splitting splitting out
(not yet: specializing) the attcacheoff-capable case.

Note that we generate N specialized functions and 1 'default' function for each
specializable function.

This feature can be disabled by removing the #define NBTS_ENABLED -line in nbtree.h
---
 src/backend/access/nbtree/README           |  22 +
 src/backend/access/nbtree/nbtdedup.c       | 300 +------
 src/backend/access/nbtree/nbtdedup_spec.h  | 313 +++++++
 src/backend/access/nbtree/nbtinsert.c      | 572 +-----------
 src/backend/access/nbtree/nbtinsert_spec.h | 569 ++++++++++++
 src/backend/access/nbtree/nbtpage.c        |   4 +-
 src/backend/access/nbtree/nbtree.c         |  31 +-
 src/backend/access/nbtree/nbtree_spec.h    |  50 ++
 src/backend/access/nbtree/nbtsearch.c      | 994 +--------------------
 src/backend/access/nbtree/nbtsearch_spec.h | 994 +++++++++++++++++++++
 src/backend/access/nbtree/nbtsort.c        | 271 +-----
 src/backend/access/nbtree/nbtsort_spec.h   | 275 ++++++
 src/backend/access/nbtree/nbtsplitloc.c    |  14 +-
 src/backend/access/nbtree/nbtutils.c       | 755 +---------------
 src/backend/access/nbtree/nbtutils_spec.h  | 772 ++++++++++++++++
 src/backend/utils/sort/tuplesort.c         |   4 +-
 src/include/access/nbtree.h                |  61 +-
 src/include/access/nbtree_specialize.h     | 204 +++++
 src/include/access/nbtree_specialized.h    |  67 ++
 19 files changed, 3357 insertions(+), 2915 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.h
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.h
 create mode 100644 src/backend/access/nbtree/nbtree_spec.h
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.h
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.h
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.h
 create mode 100644 src/include/access/nbtree_specialize.h
 create mode 100644 src/include/access/nbtree_specialized.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 5529afc1fe..3c08888c23 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1041,6 +1041,28 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+
+Notes about nbtree call specialization
+--------------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes.
+We can avoid it by specializing performance-sensitive search functions
+and calling those selectively.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.  This performance benefit is at the cost
+of binary size, so this feature can be disabled by defining NBTS_DISABLED.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - single-column indexes
+   NB: The code paths of this optimization do not support multiple key columns.
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also used for the default case, and is slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 0207421a5d..d7025d8e1c 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,259 +22,16 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
-			   Size newitemsz, bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple, and actually update the page.  Else
-			 * reset the state and move on without modifying the page.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
 
 /*
  * Perform bottom-up index deletion pass.
@@ -373,7 +130,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 			/* itup starts first pending interval */
 			_bt_dedup_start_pending(state, itup, offnum);
 		}
-		else if (_bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+		else if (nbts_call(_bt_keep_natts_fast, rel, state->base, itup) > nkeyatts &&
 				 _bt_dedup_save_htid(state, itup))
 		{
 			/* Tuple is equal; just added its TIDs to pending interval */
@@ -748,55 +505,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.h b/src/backend/access/nbtree/nbtdedup_spec.h
new file mode 100644
index 0000000000..27e5a7e686
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.h
@@ -0,0 +1,313 @@
+/*
+ * Specialized functions included in nbtdedup.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static bool NBTS_FUNCTION(_bt_do_singleval)(Relation rel, Page page, BTDedupState state,
+											OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+NBTS_FUNCTION(_bt_do_singleval)(Relation rel, Page page, BTDedupState state,
+								OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (nbts_call(_bt_keep_natts_fast, rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (nbts_call(_bt_keep_natts_fast, rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
+
+#endif /* ifndef NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+NBTS_FUNCTION(_bt_dedup_pass)(Relation rel, Buffer buf, Relation heapRel,
+							  IndexTuple newitem, Size newitemsz,
+							  bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				 minoff,
+				 maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = nbts_call(_bt_do_singleval, rel, page, state,
+								   minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 nbts_call(_bt_keep_natts_fast, rel, state->base, itup) > nkeyatts &&
+						   _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple, and actually update the page.  Else
+			 * reset the state and move on without modifying the page.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index f6f4af8bfe..ec6c73d1cc 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,18 +30,13 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
-static void _bt_stepright(Relation rel, BTInsertState insertstate, BTStack stack);
+static void _bt_stepright(Relation rel,
+										 BTInsertState insertstate,
+										 BTStack stack);
 static void _bt_insertonpg(Relation rel, BTScanInsert itup_key,
 						   Buffer buf,
 						   Buffer cbuf,
@@ -73,311 +68,10 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
-					   itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
-					  NULL);
-}
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -438,7 +132,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = nbts_call(_bt_binsrch_insert, rel, insertstate);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -483,7 +177,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset) < 0);
 				break;
 			}
 
@@ -508,7 +202,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (nbts_call(_bt_compare, rel, itup_key, page, offset) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -722,7 +416,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -769,246 +463,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
-					break;
-
-				_bt_stepright(rel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1649,7 +1103,7 @@ _bt_split(Relation rel, BTScanInsert itup_key, Buffer buf, Buffer cbuf,
 				lastleft = nposting;
 		}
 
-		lefthighkey = _bt_truncate(rel, lastleft, firstright, itup_key);
+		lefthighkey = nbts_call(_bt_truncate, rel, lastleft, firstright, itup_key);
 		itemsz = IndexTupleSize(lefthighkey);
 	}
 	else
@@ -2764,8 +2218,8 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 
 	/* Perform deduplication pass (when enabled and index-is-allequalimage) */
 	if (BTGetDeduplicateItems(rel) && itup_key->allequalimage)
-		_bt_dedup_pass(rel, buffer, heapRel, insertstate->itup,
-					   insertstate->itemsz, (indexUnchanged || uniquedup));
+		nbts_call(_bt_dedup_pass, rel, buffer, heapRel, insertstate->itup,
+				  insertstate->itemsz, (indexUnchanged || uniquedup));
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtinsert_spec.h b/src/backend/access/nbtree/nbtinsert_spec.h
new file mode 100644
index 0000000000..97c866aea3
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.h
@@ -0,0 +1,569 @@
+/*
+ * Specialized functions for nbtinsert.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static BTStack NBTS_FUNCTION(_bt_search_insert)(Relation rel,
+												BTInsertState insertstate);
+
+static OffsetNumber NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
+													 BTInsertState insertstate,
+													 bool checkingunique,
+													 bool indexUnchanged,
+													 BTStack stack,
+													 Relation heapRel);
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				nbts_call(_bt_compare, rel, insertstate->itup_key, page, P_HIKEY) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return nbts_call(_bt_search, rel, insertstate->itup_key,
+					 &insertstate->buf, BT_WRITE, NULL);
+}
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
+								 BTInsertState insertstate,
+								 bool checkingunique,
+								 bool indexUnchanged,
+								 BTStack stack,
+								 Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0)
+					break;
+
+				_bt_stepright(rel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	Assert(P_RIGHTMOST(opaque) ||
+		   nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0);
+
+	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
+
+#endif /* ifndef NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+NBTS_FUNCTION(_bt_doinsert)(Relation rel, IndexTuple itup,
+							IndexUniqueCheck checkUnique,
+							bool indexUnchanged,
+							Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = nbts_call(_bt_mkscankey, rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = nbts_call(_bt_search_insert, rel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = nbts_call(_bt_findinsertloc, rel, &insertstate, checkingunique,
+							   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
+					   itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 20adb602a4..e66299ebd8 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1967,10 +1967,10 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 				}
 
 				/* we need an insertion scan key for the search, so build one */
-				itup_key = _bt_mkscankey(rel, targetkey);
+				itup_key = nbts_call(_bt_mkscankey, rel, targetkey);
 				/* find the leftmost leaf page with matching pivot/high key */
 				itup_key->pivotsearch = true;
-				stack = _bt_search(rel, itup_key, &sleafbuf, BT_READ, NULL);
+				stack = nbts_call(_bt_search, rel, itup_key, &sleafbuf, BT_READ, NULL);
 				/* won't need a second lock or pin on leafbuf */
 				_bt_relbuf(rel, sleafbuf);
 
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 06131f23d4..09c43eb226 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,10 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -178,33 +182,6 @@ btbuildempty(Relation index)
 	smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
diff --git a/src/backend/access/nbtree/nbtree_spec.h b/src/backend/access/nbtree/nbtree_spec.h
new file mode 100644
index 0000000000..4c342287f6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.h
@@ -0,0 +1,50 @@
+/*
+ * Specialized functions for nbtree.c
+ */
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+NBTS_FUNCTION(_bt_specialize)(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	nbts_call_norel(_bt_specialize, rel, rel);
+#else
+	rel->rd_indam->aminsert = NBTS_FUNCTION(btinsert);
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+NBTS_FUNCTION(btinsert)(Relation rel, Datum *values, bool *isnull,
+						ItemPointer ht_ctid, Relation heapRel,
+						IndexUniqueCheck checkUnique,
+						bool indexUnchanged,
+						IndexInfo *indexInfo)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	nbts_call_norel(_bt_specialize, rel, rel);
+
+	return nbts_call(btinsert, rel, values, isnull, ht_ctid, heapRel,
+					 checkUnique, indexUnchanged, indexInfo);
+#else
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = nbts_call(_bt_doinsert, rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+#endif
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index c74543bfde..e81eee9c35 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,11 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -46,6 +43,9 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -70,493 +70,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- */
-BTStack
-_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
-		   Snapshot snapshot)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split
- * is completed.  'stack' is only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  Snapshot snapshot)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		page = BufferGetPage(buf);
-		TestForOldSnapshot(snapshot, rel, page);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-			break;
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
-		{
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-			break;
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-			high = mid;
-	}
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-		{
-			high = mid;
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
 
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
@@ -625,217 +138,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-			return result;
-
-		scankey++;
-	}
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -1363,7 +665,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	 * Use the manufactured insertion scan key to descend the tree and
 	 * position ourselves on the target leaf page.
 	 */
-	stack = _bt_search(rel, &inskey, &buf, BT_READ, scan->xs_snapshot);
+	stack = nbts_call(_bt_search, rel, &inskey, &buf, BT_READ, scan->xs_snapshot);
 
 	/* don't need to keep the stack around... */
 	_bt_freestack(stack);
@@ -1392,7 +694,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
@@ -1422,9 +724,9 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	/*
 	 * Now load data from the first page of the scan.
 	 */
-	if (!_bt_readpage(scan, dir, offnum))
+	if (!nbts_call_norel(_bt_readpage, scan->indexRelation, scan, dir, offnum))
 	{
-		/*
+		/*`
 		 * There's no actually-matching data on this page.  Try to advance to
 		 * the next page.  Return false if there's no matching data at all.
 		 */
@@ -1498,280 +800,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2014,7 +1042,8 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 				PredicateLockPage(rel, blkno, scan->xs_snapshot);
 				/* see if there are any matches on this page */
 				/* note that this will clear moreRight if we can stop */
-				if (_bt_readpage(scan, dir, P_FIRSTDATAKEY(opaque)))
+				if (nbts_call_norel(_bt_readpage, scan->indexRelation,
+										scan, dir, P_FIRSTDATAKEY(opaque)))
 					break;
 			}
 			else if (scan->parallel_scan != NULL)
@@ -2116,7 +1145,8 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 				PredicateLockPage(rel, BufferGetBlockNumber(so->currPos.buf), scan->xs_snapshot);
 				/* see if there are any matches on this page */
 				/* note that this will clear moreLeft if we can stop */
-				if (_bt_readpage(scan, dir, PageGetMaxOffsetNumber(page)))
+				if (nbts_call_norel(_bt_readpage, scan->indexRelation, scan,
+										dir, PageGetMaxOffsetNumber(page)))
 					break;
 			}
 			else if (scan->parallel_scan != NULL)
@@ -2448,7 +1478,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	/*
 	 * Now load data from the first page of the scan.
 	 */
-	if (!_bt_readpage(scan, dir, start))
+	if (!nbts_call_norel(_bt_readpage, scan->indexRelation, scan, dir, start))
 	{
 		/*
 		 * There's no actually-matching data on this page.  Try to advance to
diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
new file mode 100644
index 0000000000..73d5370496
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -0,0 +1,994 @@
+/*
+ * Specialized functions for nbtsearch.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel, BTScanInsert key,
+											   Buffer buf);
+static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
+										OffsetNumber offnum);
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+NBTS_FUNCTION(_bt_binsrch)(Relation rel,
+						   BTScanInsert key,
+						   Buffer buf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = nbts_call(_bt_compare, rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+			high = mid;
+	}
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
+							OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (nbts_call(_bt_checkkeys, scan->indexRelation, scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			nbts_call(_bt_checkkeys, scan->indexRelation, scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = nbts_call(_bt_checkkeys, scan->indexRelation,
+									 scan, itup, indnatts, dir,
+									 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
+
+#endif /* NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ */
+BTStack
+NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
+						  int access, Snapshot snapshot)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = nbts_call(_bt_moveright, rel, key, *bufP,
+						  (access == BT_WRITE), stack_in,
+						  page_access, snapshot);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = nbts_call(_bt_binsrch, rel, key, *bufP);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = nbts_call(_bt_moveright, rel, key, *bufP, true, stack_in,
+						  BT_WRITE, snapshot);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split
+ * is completed.  'stack' is only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ */
+Buffer
+NBTS_FUNCTION(_bt_moveright)(Relation rel,
+							 BTScanInsert key,
+							 Buffer buf,
+							 bool forupdate,
+							 BTStack stack,
+							 int access,
+							 Snapshot snapshot)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		page = BufferGetPage(buf);
+		TestForOldSnapshot(snapshot, rel, page);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+			break;
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY) >= cmpval)
+		{
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+			break;
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = nbts_call(_bt_compare, rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+		{
+			high = mid;
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+NBTS_FUNCTION(_bt_compare)(Relation rel,
+						   BTScanInsert key,
+						   Page page,
+						   OffsetNumber offnum)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+	scankey = key->scankeys;
+	for (int i = 1; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+			return result;
+
+		scankey++;
+	}
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 9f60fa9894..f1d146ba71 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,9 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
 /*
  *	btbuild() -- build a new btree index.
@@ -566,7 +567,7 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 
 	wstate.heap = btspool->heap;
 	wstate.index = btspool->index;
-	wstate.inskey = _bt_mkscankey(wstate.index, NULL);
+	wstate.inskey = nbts_call(_bt_mkscankey, wstate.index, NULL);
 	/* _bt_mkscankey() won't set allequalimage without metapage */
 	wstate.inskey->allequalimage = _bt_allequalimage(wstate.index, true);
 	wstate.btws_use_wal = RelationNeedsWAL(wstate.index);
@@ -578,7 +579,7 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE,
 								 PROGRESS_BTREE_PHASE_LEAF_LOAD);
-	_bt_load(&wstate, btspool, btspool2);
+	nbts_call_norel(_bt_load, wstate.index, &wstate, btspool, btspool2);
 }
 
 /*
@@ -978,8 +979,8 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 			lastleft = (IndexTuple) PageGetItem(opage, ii);
 
 			Assert(IndexTupleSize(oitup) > last_truncextra);
-			truncated = _bt_truncate(wstate->index, lastleft, oitup,
-									 wstate->inskey);
+			truncated = nbts_call(_bt_truncate, wstate->index, lastleft, oitup,
+								  wstate->inskey);
 			if (!PageIndexTupleOverwrite(opage, P_HIKEY, (Item) truncated,
 										 IndexTupleSize(truncated)))
 				elog(ERROR, "failed to add high key to the index page");
@@ -1176,264 +1177,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			AssertState(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.h b/src/backend/access/nbtree/nbtsort_spec.h
new file mode 100644
index 0000000000..8f4a3602ca
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.h
@@ -0,0 +1,275 @@
+/*
+ * Specialized functions included in nbtsort.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static void NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
+									BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
+						BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			AssertState(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (nbts_call(_bt_keep_natts_fast, wstate->index, dstate->base,
+							   itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
+
+#endif
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index 241e26d338..8e5337cad7 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -692,7 +692,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	{
 		itemid = PageGetItemId(state->origpage, maxoff);
 		tup = (IndexTuple) PageGetItem(state->origpage, itemid);
-		keepnatts = _bt_keep_natts_fast(state->rel, tup, state->newitem);
+		keepnatts = nbts_call(_bt_keep_natts_fast, state->rel, tup, state->newitem);
 
 		if (keepnatts > 1 && keepnatts <= nkeyatts)
 		{
@@ -723,7 +723,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 		!_bt_adjacenthtid(&tup->t_tid, &state->newitem->t_tid))
 		return false;
 	/* Check same conditions as rightmost item case, too */
-	keepnatts = _bt_keep_natts_fast(state->rel, tup, state->newitem);
+	keepnatts = nbts_call(_bt_keep_natts_fast, state->rel, tup, state->newitem);
 
 	if (keepnatts > 1 && keepnatts <= nkeyatts)
 	{
@@ -972,7 +972,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 	 * avoid appending a heap TID in new high key, we're done.  Finish split
 	 * with default strategy and initial split interval.
 	 */
-	perfectpenalty = _bt_keep_natts_fast(state->rel, leftmost, rightmost);
+	perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, leftmost, rightmost);
 	if (perfectpenalty <= indnkeyatts)
 		return perfectpenalty;
 
@@ -993,7 +993,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 	 * If page is entirely full of duplicates, a single value strategy split
 	 * will be performed.
 	 */
-	perfectpenalty = _bt_keep_natts_fast(state->rel, leftmost, rightmost);
+	perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, leftmost, rightmost);
 	if (perfectpenalty <= indnkeyatts)
 	{
 		*strategy = SPLIT_MANY_DUPLICATES;
@@ -1031,8 +1031,8 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 
 		itemid = PageGetItemId(state->origpage, P_HIKEY);
 		hikey = (IndexTuple) PageGetItem(state->origpage, itemid);
-		perfectpenalty = _bt_keep_natts_fast(state->rel, hikey,
-											 state->newitem);
+		perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, hikey,
+								   state->newitem);
 		if (perfectpenalty <= indnkeyatts)
 			*strategy = SPLIT_SINGLE_VALUE;
 		else
@@ -1154,7 +1154,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 	lastleft = _bt_split_lastleft(state, split);
 	firstright = _bt_split_firstright(state, split);
 
-	return _bt_keep_natts_fast(state->rel, lastleft, firstright);
+	return nbts_call(_bt_keep_natts_fast, state->rel, lastleft, firstright);
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index ff260c393a..bc443ebd27 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,11 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1221,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1704,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
new file mode 100644
index 0000000000..a4b934ae7a
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.h
@@ -0,0 +1,772 @@
+/*
+ * Specialized functions included in nbtutils.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static bool NBTS_FUNCTION(_bt_check_rowcompare)(ScanKey skey,
+												IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+												ScanDirection dir, bool *continuescan);
+
+static int	NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
+										  IndexTuple firstright, BTScanInsert itup_key);
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+NBTS_FUNCTION(_bt_check_rowcompare)(ScanKey skey, IndexTuple tuple,
+									int tupnatts, TupleDesc tupdesc,
+									ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
+							  IndexTuple firstright, BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == nbts_call(_bt_keep_natts_fast, rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+#endif /* NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+NBTS_FUNCTION(_bt_checkkeys)(Relation rel, IndexScanDesc scan,
+							 IndexTuple tuple, int tupnatts,
+							 ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (nbts_call_norel(_bt_check_rowcompare, rel, key, tuple,
+								tupnatts, tupdesc, dir, continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+NBTS_FUNCTION(_bt_truncate)(Relation rel, IndexTuple lastleft,
+							IndexTuple firstright, BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = nbts_call(_bt_keep_natts, rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel,
+								   IndexTuple lastleft,
+								   IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 1174e1a31c..816165217e 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -1122,7 +1122,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 
 	state->tupDesc = tupDesc;	/* assume we need not copy tupDesc */
 
-	indexScanKey = _bt_mkscankey(indexRel, NULL);
+	indexScanKey = nbts_call(_bt_mkscankey, indexRel, NULL);
 
 	if (state->indexInfo->ii_Expressions != NULL)
 	{
@@ -1220,7 +1220,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	state->enforceUnique = enforceUnique;
 	state->uniqueNullsNotDistinct = uniqueNullsNotDistinct;
 
-	indexScanKey = _bt_mkscankey(indexRel, NULL);
+	indexScanKey = nbts_call(_bt_mkscankey, indexRel, NULL);
 
 	/* Prepare SortSupport data for each column */
 	state->sortKeys = (SortSupport) palloc0(state->nKeys *
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 93f8267b48..83e0dbab16 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1116,15 +1116,47 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+
+
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define NBTS_ENABLED
+
+#ifdef NBTS_ENABLED
+
+/*
+ * Access a specialized nbtree function, based on the shape of the index key.
+ */
+
+#define NBT_SPECIALIZE_CALL(function, rel, ...) \
+( \
+	NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+)
+
+#else /* not defined NBTS_ENABLED */
+
+#define NBT_SPECIALIZE_CALL(function, rel, ...) function(__VA_ARGS__)
+
+#endif /* NBTS_ENABLED */
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specialized.h"
+#include "nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1155,9 +1187,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
-						   IndexTuple newitem, Size newitemsz,
-						   bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1173,9 +1202,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Buffer lbuf, BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, BTStack stack, BlockNumber child);
 
@@ -1223,12 +1249,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
-						  int access, Snapshot snapshot);
-extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
@@ -1237,7 +1257,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1245,8 +1264,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1259,10 +1276,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
new file mode 100644
index 0000000000..23fdda4f0e
--- /dev/null
+++ b/src/include/access/nbtree_specialize.h
@@ -0,0 +1,204 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_call(function, indexrel, ...rest_of_args), and
+ *   nbts_call_norel(function, indexrel, ...args)
+ *     This will call the specialized variant of 'function' based on the index
+ *     relation data.
+ *     The difference between nbts_call and nbts_call_norel is that _call
+ *     uses indexrel as first argument in the function call, whereas
+ *     nbts_call_norel does not.
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ *
+ * example usage:
+ *
+ * kwithnulls = nbts_call_norel(_bt_key_hasnulls, myindex, mytuple, tupDesc);
+ *
+ * NBTS_FUNCTION(_bt_key_hasnulls)(IndexTuple mytuple, TupleDesc tupDesc)
+ * {
+ *    nbts_attiterdeclare(mytuple);
+ *    nbts_attiterinit(mytuple, 1, tupDesc);
+ *    nbts_foreachattr(1, 10)
+ *    {
+ *        Datum it = nbts_attiter_nextattdatum(tuple, tupDesc);
+ *        if (nbts_attiter_curattisnull(tuple))
+ *           return true;
+ *    }
+ *    return false
+ * }
+ */
+
+/*
+ * Call a potentially specialized function for a given btree operation.
+ *
+ * NB: the rel argument is evaluated multiple times.
+ */
+#define nbts_call(name, rel, ...) \
+	nbts_call_norel(name, (rel), (rel), __VA_ARGS__)
+
+#ifdef NBTS_ENABLED
+
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+#ifdef nbts_call_norel
+#undef nbts_call_norel
+#endif
+
+#define nbts_call_norel(name, rel, ...) \
+	(NBTS_FUNCTION(name)(__VA_ARGS__))
+
+/*
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_CACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/* reset call to SPECIALIZE_CALL for default behaviour */
+#undef nbts_call_norel
+#define nbts_call_norel(name, rel, ...) \
+	NBT_SPECIALIZE_CALL(name, (rel), __VA_ARGS__)
+
+/*
+ * "Default", externally accessible, not so much optimized functions
+ */
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+/* for the default functions, we want to use the unspecialized name. */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) name
+
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/* from here on there are no more NBTS_FUNCTIONs */
+#undef NBTS_FUNCTION
+
+#else /* not defined NBTS_ENABLED */
+
+/*
+ * NBTS_ENABLE is not defined, so we don't want to use the specializations.
+ * We revert to the behaviour from PG14 and earlier, which only uses
+ * attcacheoff.
+ */
+
+#define NBTS_FUNCTION(name) name
+
+#define nbts_call_norel(name, rel, ...) \
+	name(__VA_ARGS__)
+
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+
+#endif /* !NBTS_ENABLED */
diff --git a/src/include/access/nbtree_specialized.h b/src/include/access/nbtree_specialized.h
new file mode 100644
index 0000000000..c45fa84aed
--- /dev/null
+++ b/src/include/access/nbtree_specialized.h
@@ -0,0 +1,67 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void
+NBTS_FUNCTION(_bt_specialize)(Relation rel);
+
+extern bool
+NBTS_FUNCTION(btinsert)(Relation rel, Datum *values, bool *isnull,
+						ItemPointer ht_ctid, Relation heapRel,
+						IndexUniqueCheck checkUnique,
+						bool indexUnchanged,
+						struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void
+NBTS_FUNCTION(_bt_dedup_pass)(Relation rel, Buffer buf, Relation heapRel,
+							  IndexTuple newitem, Size newitemsz,
+							  bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool
+NBTS_FUNCTION(_bt_doinsert)(Relation rel, IndexTuple itup,
+							IndexUniqueCheck checkUnique, bool indexUnchanged,
+							Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack
+NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key,
+						  Buffer *bufP, int access,
+						  Snapshot snapshot);
+extern Buffer
+NBTS_FUNCTION(_bt_moveright)(Relation rel, BTScanInsert key, Buffer buf,
+							 bool forupdate, BTStack stack, int access,
+							 Snapshot snapshot);
+extern OffsetNumber
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate);
+extern int32
+NBTS_FUNCTION(_bt_compare)(Relation rel, BTScanInsert key,
+						   Page page, OffsetNumber offnum);
+
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert
+NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup);
+extern bool
+NBTS_FUNCTION(_bt_checkkeys)(Relation rel, IndexScanDesc scan,
+							 IndexTuple tuple, int tupnatts,
+							 ScanDirection dir, bool *continuescan);
+extern IndexTuple
+NBTS_FUNCTION(_bt_truncate)(Relation rel, IndexTuple lastleft,
+							IndexTuple firstright, BTScanInsert itup_key);
+extern int
+NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel, IndexTuple lastleft,
+								   IndexTuple firstright);
-- 
2.30.2

From b694db3e884b06b7f6e4508f41ee2a2288f73c20 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:44:01 +0200
Subject: [PATCH v2 6/7] Implement specialized uncacheable attribute iteration

Uses an iterator to prevent doing duplicate work while iterating over
attributes.

Inspiration: https://www.postgresql.org/message-id/CAEze2WjE9ka8i%3Ds-Vv5oShro9xTrt5VQnQvFG9AaRwWpMm3-fg%40mail.gmail.com
---
 src/include/access/itup.h              | 179 +++++++++++++++++++++++++
 src/include/access/nbtree.h            |  12 +-
 src/include/access/nbtree_specialize.h |  34 +++++
 3 files changed, 223 insertions(+), 2 deletions(-)

diff --git a/src/include/access/itup.h b/src/include/access/itup.h
index 2c8877e991..cc29614107 100644
--- a/src/include/access/itup.h
+++ b/src/include/access/itup.h
@@ -59,6 +59,15 @@ typedef struct IndexAttributeBitMapData
 
 typedef IndexAttributeBitMapData * IndexAttributeBitMap;
 
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
 /*
  * t_info manipulation macros
  */
@@ -126,6 +135,42 @@ typedef IndexAttributeBitMapData * IndexAttributeBitMap;
 	) \
 )
 
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
 /*
  * MaxIndexTuplesPerPage is an upper bound on the number of tuples that can
  * fit on one index page.  An index tuple must have either data or a null
@@ -161,4 +206,138 @@ extern IndexTuple CopyIndexTuple(IndexTuple source);
 extern IndexTuple index_truncate_tuple(TupleDesc sourceDescriptor,
 									   IndexTuple source, int leavenatts);
 
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
 #endif							/* ITUP_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 1559399b0e..80f2575884 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1122,6 +1122,7 @@ typedef struct BTOptions
  */
 #define NBTS_TYPE_SINGLE_COLUMN single
 #define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_DEFAULT default
 
 
@@ -1152,12 +1153,19 @@ do { \
 
 #define NBT_SPECIALIZE_CALL(function, rel, ...) \
 ( \
-	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? (   \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? ( \
 		NBTS_MAKE_NAME(function, NBTS_TYPE_SINGLE_COLUMN)(__VA_ARGS__) \
 	) \
 	: \
 	( \
-		NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+		TupleDescAttr(RelationGetDescr(rel), \
+					  IndexRelationGetNumberOfKeyAttributes(rel) - 1)->attcacheoff > 0 ? ( \
+			NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+		) \
+		: \
+		( \
+			NBTS_MAKE_NAME(function, NBTS_TYPE_UNCACHED)(__VA_ARGS__) \
+		) \
 	) \
 )
 
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
index 642bc4c795..52739d390e 100644
--- a/src/include/access/nbtree_specialize.h
+++ b/src/include/access/nbtree_specialize.h
@@ -168,6 +168,40 @@
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /* reset call to SPECIALIZE_CALL for default behaviour */
 #undef nbts_call_norel
 #define nbts_call_norel(name, rel, ...) \
-- 
2.30.2

From 16a6f12b795cb50b3a3f1f246f7c964d53e807f7 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 15 Apr 2022 18:25:38 +0200
Subject: [PATCH v2 7/7] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the scan attributes
on both sides of the compared tuple are equal to the scankey, then the current
tuple that is being compared must also have those prefixing attributes that
equal the scankey.

We cannot propagate this information to _binsrch on lower pages, as this
downstream page may concurrently have split and/or have merged with its
deleted left neighbour (see [0]), which moves the keyspace of the linked page.
We thus can only trust the current state of this current page for this
optimization, which means we must validate this state each time we open the
page.

Although this limits the overall performance improvement, it still allows
for a nice performance improvement in most cases where initial columns have
many duplicate values and a compare function that is not cheap.
---
 contrib/amcheck/verify_nbtree.c            | 17 +++--
 src/backend/access/nbtree/README           | 25 ++++++++
 src/backend/access/nbtree/nbtinsert.c      | 14 ++--
 src/backend/access/nbtree/nbtinsert_spec.h | 22 +++++--
 src/backend/access/nbtree/nbtsearch.c      |  2 +-
 src/backend/access/nbtree/nbtsearch_spec.h | 75 +++++++++++++++++-----
 src/include/access/nbtree_specialized.h    |  8 ++-
 7 files changed, 127 insertions(+), 36 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 70278c4f93..5753611546 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2673,6 +2673,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2682,13 +2683,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2750,6 +2751,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2760,7 +2762,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2812,10 +2814,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2835,10 +2838,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2873,13 +2877,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 3c08888c23..13ac9ee2be 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,31 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+potentially saving cycles.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by an inner page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. (2,2) to (1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+The positive part of this, is that we already have results of the highest
+value of a page: a pages' highkey is compared to the scankey while we have
+a pin on the page in the _bt_moveright procedure. The _bt_binsrch procedure
+will use this result as a rightmost prefix compare, and for each step in the
+binary search (that does not compare less than the insert key) improve the
+equal-prefix bounds.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index ec6c73d1cc..20e5f33f98 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -132,7 +132,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = nbts_call(_bt_binsrch_insert, rel, insertstate);
+	offset = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -142,6 +142,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -177,7 +179,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset) < 0);
+				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset,
+								 &cmpcol) < 0);
 				break;
 			}
 
@@ -202,7 +205,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (nbts_call(_bt_compare, rel, itup_key, page, offset) != 0)
+					if (nbts_call(_bt_compare, rel, itup_key, page, offset,
+								  &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -412,11 +416,13 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY);
+			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY,
+								   &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
diff --git a/src/backend/access/nbtree/nbtinsert_spec.h b/src/backend/access/nbtree/nbtinsert_spec.h
index 97c866aea3..ccba0fa5ed 100644
--- a/src/backend/access/nbtree/nbtinsert_spec.h
+++ b/src/backend/access/nbtree/nbtinsert_spec.h
@@ -73,6 +73,7 @@ NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	comparecol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -91,7 +92,8 @@ NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				nbts_call(_bt_compare, rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				nbts_call(_bt_compare, rel, insertstate->itup_key, page,
+						  P_HIKEY, &comparecol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -221,6 +223,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -238,7 +241,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0)
+					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, insertstate, stack);
@@ -291,6 +294,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -321,7 +325,8 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) != 0 ||
+				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY,
+						  &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -336,10 +341,13 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) || nbts_call(_bt_compare, rel, itup_key,
+												page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -358,7 +366,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index d5152bfcb7..036ce88679 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -696,7 +696,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf);
+	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf, 1);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
index a5c5f2b94f..829c216819 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.h
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -10,8 +10,10 @@
  */
 #ifndef NBTS_SPECIALIZING_DEFAULT
 
-static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel, BTScanInsert key,
-											   Buffer buf);
+static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel,
+											   BTScanInsert key,
+											   Buffer buf,
+											   AttrNumber highkeycmpcol);
 static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
 										OffsetNumber offnum);
 
@@ -38,7 +40,8 @@ static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
 static OffsetNumber
 NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 						   BTScanInsert key,
-						   Buffer buf)
+						   Buffer buf,
+						   AttrNumber highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -46,6 +49,8 @@ NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	AttrNumber	highcmpcol = highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -87,15 +92,22 @@ NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = nbts_call(_bt_compare, rel, key, page, mid);
+		result = nbts_call(_bt_compare, rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
 
 	/*
@@ -441,6 +453,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		IndexTuple	itup;
 		BlockNumber child;
 		BTStack		new_stack;
+		AttrNumber	highkeycmpcol = 1;
 
 		/*
 		 * Race -- the page we just grabbed may have split since we read its
@@ -456,7 +469,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 */
 		*bufP = nbts_call(_bt_moveright, rel, key, *bufP,
 						  (access == BT_WRITE), stack_in,
-						  page_access, snapshot);
+						  page_access, snapshot, &highkeycmpcol);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -468,7 +481,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = nbts_call(_bt_binsrch, rel, key, *bufP);
+		offnum = nbts_call(_bt_binsrch, rel, key, *bufP, highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
@@ -507,6 +520,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		AttrNumber highkeycmpcol = 1;
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -517,7 +531,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = nbts_call(_bt_moveright, rel, key, *bufP, true, stack_in,
-						  BT_WRITE, snapshot);
+						  BT_WRITE, snapshot, &highkeycmpcol);
 	}
 
 	return stack_in;
@@ -565,12 +579,15 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 							 bool forupdate,
 							 BTStack stack,
 							 int access,
-							 Snapshot snapshot)
+							 Snapshot snapshot,
+							 AttrNumber *comparecol)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
+	Assert(PointerIsValid(comparecol));
+
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
 	 * this page is > the high key stored on the page, then the page has split
@@ -592,12 +609,17 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -623,14 +645,19 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY) >= cmpval)
+		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY,
+										  &cmpcol) >= cmpval)
 		{
 			/* step right one page */
+			*comparecol = 1;
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -663,7 +690,8 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
  * list split).
  */
 OffsetNumber
-NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate,
+								  AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -673,6 +701,7 @@ NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -723,16 +752,21 @@ NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = nbts_call(_bt_compare, rel, key, page, mid);
+		result = nbts_call(_bt_compare, rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -813,7 +847,8 @@ int32
 NBTS_FUNCTION(_bt_compare)(Relation rel,
 						   BTScanInsert key,
 						   Page page,
-						   OffsetNumber offnum)
+						   OffsetNumber offnum,
+						   AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -854,10 +889,11 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	nbts_attiterinit(itup, 1, itupdesc);
 
-	nbts_foreachattr(1, ncmpkey)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+	scankey = key->scankeys + ((*comparecol) - 1);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
 
@@ -902,11 +938,20 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = nbts_attiter_attnum;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
diff --git a/src/include/access/nbtree_specialized.h b/src/include/access/nbtree_specialized.h
index c45fa84aed..7402a4c46e 100644
--- a/src/include/access/nbtree_specialized.h
+++ b/src/include/access/nbtree_specialized.h
@@ -43,12 +43,14 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key,
 extern Buffer
 NBTS_FUNCTION(_bt_moveright)(Relation rel, BTScanInsert key, Buffer buf,
 							 bool forupdate, BTStack stack, int access,
-							 Snapshot snapshot);
+							 Snapshot snapshot, AttrNumber *comparecol);
 extern OffsetNumber
-NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate);
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate,
+								  AttrNumber highcmpcol);
 extern int32
 NBTS_FUNCTION(_bt_compare)(Relation rel, BTScanInsert key,
-						   Page page, OffsetNumber offnum);
+						   Page page, OffsetNumber offnum,
+						   AttrNumber *comparecol);
 
 /*
  * prototypes for functions in nbtutils_spec.h
-- 
2.30.2

From eb05201ec8f207aec3c106813424477b9ab3c454 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:54:52 +0200
Subject: [PATCH v3 3/9] Specialize the nbtree rd_indam entry.

Because each rd_indam struct is seperately allocated for each index, we can
freely modify it at runtime without impacting other indexes of the same
access method. For btinsert (which effectively only calls _bt_insert) it is
useful to specialize that function, which also makes rd_indam->aminsert a
good signal whether or not the indexRelation has been fully optimized yet.
---
 src/backend/access/nbtree/nbtree.c    |  7 +++++++
 src/backend/access/nbtree/nbtsearch.c |  2 ++
 src/backend/access/nbtree/nbtsort.c   |  2 ++
 src/include/access/nbtree.h           | 14 ++++++++++++++
 4 files changed, 25 insertions(+)

diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 09c43eb226..95da2c46bf 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -161,6 +161,8 @@ btbuildempty(Relation index)
 	metapage = (Page) palloc(BLCKSZ);
 	_bt_initmetapage(metapage, P_NONE, 0, _bt_allequalimage(index, false));
 
+	nbt_opt_specialize(index);
+
 	/*
 	 * Write the page and log it.  It might seem that an immediate sync would
 	 * be sufficient to guarantee that the file exists on disk, but recovery
@@ -323,6 +325,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -765,6 +769,7 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 {
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
+	nbt_opt_specialize(info->index);
 
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
@@ -798,6 +803,8 @@ btvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
 	if (info->analyze_only)
 		return stats;
 
+	nbt_opt_specialize(info->index);
+
 	/*
 	 * If btbulkdelete was called, we need not do anything (we just maintain
 	 * the information used within _bt_vacuum_needs_cleanup() by calling
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index e81eee9c35..d5152bfcb7 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -181,6 +181,8 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
+	nbt_opt_specialize(scan->indexRelation);
+
 	pgstat_count_index_scan(rel);
 
 	/*
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index f1d146ba71..22c7163197 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -305,6 +305,8 @@ btbuild(Relation heap, Relation index, IndexInfo *indexInfo)
 	BTBuildState buildstate;
 	double		reltuples;
 
+	nbt_opt_specialize(index);
+
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
 		ResetUsage();
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 83e0dbab16..489b623663 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1132,6 +1132,19 @@ typedef struct BTOptions
 
 #ifdef NBTS_ENABLED
 
+/*
+ * Replace the functions in the rd_indam struct with a variant optimized for
+ * our key shape, if not already done.
+ *
+ * It only needs to be done once for every index relation loaded, so it's
+ * quite unlikely we need to do this and thus marked unlikely().
+ */
+#define nbt_opt_specialize(rel) \
+do { \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert)) \
+		_bt_specialize(rel); \
+} while (false)
+
 /*
  * Access a specialized nbtree function, based on the shape of the index key.
  */
@@ -1143,6 +1156,7 @@ typedef struct BTOptions
 
 #else /* not defined NBTS_ENABLED */
 
+#define nbt_opt_specialize(rel)
 #define NBT_SPECIALIZE_CALL(function, rel, ...) function(__VA_ARGS__)
 
 #endif /* NBTS_ENABLED */
-- 
2.30.2

From 1ff81e78ae0cecbe2d46735b26e0fad049f45772 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Sun, 30 Jan 2022 16:23:31 +0100
Subject: [PATCH v3 1/9] Specialize nbtree functions on btree key shape

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, initially splitting splitting out
(not yet: specializing) the attcacheoff-capable case.

Note that we generate N specialized functions and 1 'default' function for each
specializable function.

This feature can be disabled by removing the #define NBTS_ENABLED -line in nbtree.h
---
 src/backend/access/nbtree/README           |  22 +
 src/backend/access/nbtree/nbtdedup.c       | 300 +------
 src/backend/access/nbtree/nbtdedup_spec.h  | 313 +++++++
 src/backend/access/nbtree/nbtinsert.c      | 572 +-----------
 src/backend/access/nbtree/nbtinsert_spec.h | 569 ++++++++++++
 src/backend/access/nbtree/nbtpage.c        |   4 +-
 src/backend/access/nbtree/nbtree.c         |  31 +-
 src/backend/access/nbtree/nbtree_spec.h    |  50 ++
 src/backend/access/nbtree/nbtsearch.c      | 994 +--------------------
 src/backend/access/nbtree/nbtsearch_spec.h | 994 +++++++++++++++++++++
 src/backend/access/nbtree/nbtsort.c        | 271 +-----
 src/backend/access/nbtree/nbtsort_spec.h   | 275 ++++++
 src/backend/access/nbtree/nbtsplitloc.c    |  14 +-
 src/backend/access/nbtree/nbtutils.c       | 755 +---------------
 src/backend/access/nbtree/nbtutils_spec.h  | 772 ++++++++++++++++
 src/backend/utils/sort/tuplesort.c         |   4 +-
 src/include/access/nbtree.h                |  61 +-
 src/include/access/nbtree_specialize.h     | 204 +++++
 src/include/access/nbtree_specialized.h    |  67 ++
 19 files changed, 3357 insertions(+), 2915 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.h
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.h
 create mode 100644 src/backend/access/nbtree/nbtree_spec.h
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.h
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.h
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.h
 create mode 100644 src/include/access/nbtree_specialize.h
 create mode 100644 src/include/access/nbtree_specialized.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 5529afc1fe..3c08888c23 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1041,6 +1041,28 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+
+Notes about nbtree call specialization
+--------------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes.
+We can avoid it by specializing performance-sensitive search functions
+and calling those selectively.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.  This performance benefit is at the cost
+of binary size, so this feature can be disabled by defining NBTS_DISABLED.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - single-column indexes
+   NB: The code paths of this optimization do not support multiple key columns.
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also used for the default case, and is slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 0207421a5d..d7025d8e1c 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,259 +22,16 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
-			   Size newitemsz, bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple, and actually update the page.  Else
-			 * reset the state and move on without modifying the page.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
 
 /*
  * Perform bottom-up index deletion pass.
@@ -373,7 +130,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 			/* itup starts first pending interval */
 			_bt_dedup_start_pending(state, itup, offnum);
 		}
-		else if (_bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+		else if (nbts_call(_bt_keep_natts_fast, rel, state->base, itup) > nkeyatts &&
 				 _bt_dedup_save_htid(state, itup))
 		{
 			/* Tuple is equal; just added its TIDs to pending interval */
@@ -748,55 +505,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.h b/src/backend/access/nbtree/nbtdedup_spec.h
new file mode 100644
index 0000000000..27e5a7e686
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.h
@@ -0,0 +1,313 @@
+/*
+ * Specialized functions included in nbtdedup.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static bool NBTS_FUNCTION(_bt_do_singleval)(Relation rel, Page page, BTDedupState state,
+											OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+NBTS_FUNCTION(_bt_do_singleval)(Relation rel, Page page, BTDedupState state,
+								OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (nbts_call(_bt_keep_natts_fast, rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (nbts_call(_bt_keep_natts_fast, rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
+
+#endif /* ifndef NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+NBTS_FUNCTION(_bt_dedup_pass)(Relation rel, Buffer buf, Relation heapRel,
+							  IndexTuple newitem, Size newitemsz,
+							  bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				 minoff,
+				 maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = nbts_call(_bt_do_singleval, rel, page, state,
+								   minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 nbts_call(_bt_keep_natts_fast, rel, state->base, itup) > nkeyatts &&
+						   _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple, and actually update the page.  Else
+			 * reset the state and move on without modifying the page.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index f6f4af8bfe..ec6c73d1cc 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,18 +30,13 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
-static void _bt_stepright(Relation rel, BTInsertState insertstate, BTStack stack);
+static void _bt_stepright(Relation rel,
+										 BTInsertState insertstate,
+										 BTStack stack);
 static void _bt_insertonpg(Relation rel, BTScanInsert itup_key,
 						   Buffer buf,
 						   Buffer cbuf,
@@ -73,311 +68,10 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
-					   itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
-					  NULL);
-}
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -438,7 +132,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = nbts_call(_bt_binsrch_insert, rel, insertstate);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -483,7 +177,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset) < 0);
 				break;
 			}
 
@@ -508,7 +202,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (nbts_call(_bt_compare, rel, itup_key, page, offset) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -722,7 +416,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -769,246 +463,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
-					break;
-
-				_bt_stepright(rel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1649,7 +1103,7 @@ _bt_split(Relation rel, BTScanInsert itup_key, Buffer buf, Buffer cbuf,
 				lastleft = nposting;
 		}
 
-		lefthighkey = _bt_truncate(rel, lastleft, firstright, itup_key);
+		lefthighkey = nbts_call(_bt_truncate, rel, lastleft, firstright, itup_key);
 		itemsz = IndexTupleSize(lefthighkey);
 	}
 	else
@@ -2764,8 +2218,8 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 
 	/* Perform deduplication pass (when enabled and index-is-allequalimage) */
 	if (BTGetDeduplicateItems(rel) && itup_key->allequalimage)
-		_bt_dedup_pass(rel, buffer, heapRel, insertstate->itup,
-					   insertstate->itemsz, (indexUnchanged || uniquedup));
+		nbts_call(_bt_dedup_pass, rel, buffer, heapRel, insertstate->itup,
+				  insertstate->itemsz, (indexUnchanged || uniquedup));
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtinsert_spec.h b/src/backend/access/nbtree/nbtinsert_spec.h
new file mode 100644
index 0000000000..97c866aea3
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.h
@@ -0,0 +1,569 @@
+/*
+ * Specialized functions for nbtinsert.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static BTStack NBTS_FUNCTION(_bt_search_insert)(Relation rel,
+												BTInsertState insertstate);
+
+static OffsetNumber NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
+													 BTInsertState insertstate,
+													 bool checkingunique,
+													 bool indexUnchanged,
+													 BTStack stack,
+													 Relation heapRel);
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				nbts_call(_bt_compare, rel, insertstate->itup_key, page, P_HIKEY) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return nbts_call(_bt_search, rel, insertstate->itup_key,
+					 &insertstate->buf, BT_WRITE, NULL);
+}
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
+								 BTInsertState insertstate,
+								 bool checkingunique,
+								 bool indexUnchanged,
+								 BTStack stack,
+								 Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0)
+					break;
+
+				_bt_stepright(rel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	Assert(P_RIGHTMOST(opaque) ||
+		   nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0);
+
+	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
+
+#endif /* ifndef NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+NBTS_FUNCTION(_bt_doinsert)(Relation rel, IndexTuple itup,
+							IndexUniqueCheck checkUnique,
+							bool indexUnchanged,
+							Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = nbts_call(_bt_mkscankey, rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = nbts_call(_bt_search_insert, rel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = nbts_call(_bt_findinsertloc, rel, &insertstate, checkingunique,
+							   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
+					   itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 20adb602a4..e66299ebd8 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1967,10 +1967,10 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 				}
 
 				/* we need an insertion scan key for the search, so build one */
-				itup_key = _bt_mkscankey(rel, targetkey);
+				itup_key = nbts_call(_bt_mkscankey, rel, targetkey);
 				/* find the leftmost leaf page with matching pivot/high key */
 				itup_key->pivotsearch = true;
-				stack = _bt_search(rel, itup_key, &sleafbuf, BT_READ, NULL);
+				stack = nbts_call(_bt_search, rel, itup_key, &sleafbuf, BT_READ, NULL);
 				/* won't need a second lock or pin on leafbuf */
 				_bt_relbuf(rel, sleafbuf);
 
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 06131f23d4..09c43eb226 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,10 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -178,33 +182,6 @@ btbuildempty(Relation index)
 	smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
diff --git a/src/backend/access/nbtree/nbtree_spec.h b/src/backend/access/nbtree/nbtree_spec.h
new file mode 100644
index 0000000000..4c342287f6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.h
@@ -0,0 +1,50 @@
+/*
+ * Specialized functions for nbtree.c
+ */
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+NBTS_FUNCTION(_bt_specialize)(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	nbts_call_norel(_bt_specialize, rel, rel);
+#else
+	rel->rd_indam->aminsert = NBTS_FUNCTION(btinsert);
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+NBTS_FUNCTION(btinsert)(Relation rel, Datum *values, bool *isnull,
+						ItemPointer ht_ctid, Relation heapRel,
+						IndexUniqueCheck checkUnique,
+						bool indexUnchanged,
+						IndexInfo *indexInfo)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	nbts_call_norel(_bt_specialize, rel, rel);
+
+	return nbts_call(btinsert, rel, values, isnull, ht_ctid, heapRel,
+					 checkUnique, indexUnchanged, indexInfo);
+#else
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = nbts_call(_bt_doinsert, rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+#endif
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index c74543bfde..e81eee9c35 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,11 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -46,6 +43,9 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -70,493 +70,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- */
-BTStack
-_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
-		   Snapshot snapshot)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split
- * is completed.  'stack' is only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  Snapshot snapshot)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		page = BufferGetPage(buf);
-		TestForOldSnapshot(snapshot, rel, page);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-			break;
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
-		{
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-			break;
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-			high = mid;
-	}
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-		{
-			high = mid;
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
 
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
@@ -625,217 +138,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-			return result;
-
-		scankey++;
-	}
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -1363,7 +665,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	 * Use the manufactured insertion scan key to descend the tree and
 	 * position ourselves on the target leaf page.
 	 */
-	stack = _bt_search(rel, &inskey, &buf, BT_READ, scan->xs_snapshot);
+	stack = nbts_call(_bt_search, rel, &inskey, &buf, BT_READ, scan->xs_snapshot);
 
 	/* don't need to keep the stack around... */
 	_bt_freestack(stack);
@@ -1392,7 +694,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
@@ -1422,9 +724,9 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	/*
 	 * Now load data from the first page of the scan.
 	 */
-	if (!_bt_readpage(scan, dir, offnum))
+	if (!nbts_call_norel(_bt_readpage, scan->indexRelation, scan, dir, offnum))
 	{
-		/*
+		/*`
 		 * There's no actually-matching data on this page.  Try to advance to
 		 * the next page.  Return false if there's no matching data at all.
 		 */
@@ -1498,280 +800,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2014,7 +1042,8 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 				PredicateLockPage(rel, blkno, scan->xs_snapshot);
 				/* see if there are any matches on this page */
 				/* note that this will clear moreRight if we can stop */
-				if (_bt_readpage(scan, dir, P_FIRSTDATAKEY(opaque)))
+				if (nbts_call_norel(_bt_readpage, scan->indexRelation,
+										scan, dir, P_FIRSTDATAKEY(opaque)))
 					break;
 			}
 			else if (scan->parallel_scan != NULL)
@@ -2116,7 +1145,8 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 				PredicateLockPage(rel, BufferGetBlockNumber(so->currPos.buf), scan->xs_snapshot);
 				/* see if there are any matches on this page */
 				/* note that this will clear moreLeft if we can stop */
-				if (_bt_readpage(scan, dir, PageGetMaxOffsetNumber(page)))
+				if (nbts_call_norel(_bt_readpage, scan->indexRelation, scan,
+										dir, PageGetMaxOffsetNumber(page)))
 					break;
 			}
 			else if (scan->parallel_scan != NULL)
@@ -2448,7 +1478,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	/*
 	 * Now load data from the first page of the scan.
 	 */
-	if (!_bt_readpage(scan, dir, start))
+	if (!nbts_call_norel(_bt_readpage, scan->indexRelation, scan, dir, start))
 	{
 		/*
 		 * There's no actually-matching data on this page.  Try to advance to
diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
new file mode 100644
index 0000000000..73d5370496
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -0,0 +1,994 @@
+/*
+ * Specialized functions for nbtsearch.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel, BTScanInsert key,
+											   Buffer buf);
+static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
+										OffsetNumber offnum);
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+NBTS_FUNCTION(_bt_binsrch)(Relation rel,
+						   BTScanInsert key,
+						   Buffer buf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = nbts_call(_bt_compare, rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+			high = mid;
+	}
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
+							OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (nbts_call(_bt_checkkeys, scan->indexRelation, scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			nbts_call(_bt_checkkeys, scan->indexRelation, scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = nbts_call(_bt_checkkeys, scan->indexRelation,
+									 scan, itup, indnatts, dir,
+									 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
+
+#endif /* NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ */
+BTStack
+NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
+						  int access, Snapshot snapshot)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = nbts_call(_bt_moveright, rel, key, *bufP,
+						  (access == BT_WRITE), stack_in,
+						  page_access, snapshot);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = nbts_call(_bt_binsrch, rel, key, *bufP);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = nbts_call(_bt_moveright, rel, key, *bufP, true, stack_in,
+						  BT_WRITE, snapshot);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split
+ * is completed.  'stack' is only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ */
+Buffer
+NBTS_FUNCTION(_bt_moveright)(Relation rel,
+							 BTScanInsert key,
+							 Buffer buf,
+							 bool forupdate,
+							 BTStack stack,
+							 int access,
+							 Snapshot snapshot)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		page = BufferGetPage(buf);
+		TestForOldSnapshot(snapshot, rel, page);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+			break;
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY) >= cmpval)
+		{
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+			break;
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = nbts_call(_bt_compare, rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+		{
+			high = mid;
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+NBTS_FUNCTION(_bt_compare)(Relation rel,
+						   BTScanInsert key,
+						   Page page,
+						   OffsetNumber offnum)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+	scankey = key->scankeys;
+	for (int i = 1; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+			return result;
+
+		scankey++;
+	}
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 9f60fa9894..f1d146ba71 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,9 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
 /*
  *	btbuild() -- build a new btree index.
@@ -566,7 +567,7 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 
 	wstate.heap = btspool->heap;
 	wstate.index = btspool->index;
-	wstate.inskey = _bt_mkscankey(wstate.index, NULL);
+	wstate.inskey = nbts_call(_bt_mkscankey, wstate.index, NULL);
 	/* _bt_mkscankey() won't set allequalimage without metapage */
 	wstate.inskey->allequalimage = _bt_allequalimage(wstate.index, true);
 	wstate.btws_use_wal = RelationNeedsWAL(wstate.index);
@@ -578,7 +579,7 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE,
 								 PROGRESS_BTREE_PHASE_LEAF_LOAD);
-	_bt_load(&wstate, btspool, btspool2);
+	nbts_call_norel(_bt_load, wstate.index, &wstate, btspool, btspool2);
 }
 
 /*
@@ -978,8 +979,8 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 			lastleft = (IndexTuple) PageGetItem(opage, ii);
 
 			Assert(IndexTupleSize(oitup) > last_truncextra);
-			truncated = _bt_truncate(wstate->index, lastleft, oitup,
-									 wstate->inskey);
+			truncated = nbts_call(_bt_truncate, wstate->index, lastleft, oitup,
+								  wstate->inskey);
 			if (!PageIndexTupleOverwrite(opage, P_HIKEY, (Item) truncated,
 										 IndexTupleSize(truncated)))
 				elog(ERROR, "failed to add high key to the index page");
@@ -1176,264 +1177,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			AssertState(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.h b/src/backend/access/nbtree/nbtsort_spec.h
new file mode 100644
index 0000000000..8f4a3602ca
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.h
@@ -0,0 +1,275 @@
+/*
+ * Specialized functions included in nbtsort.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static void NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
+									BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
+						BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			AssertState(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (nbts_call(_bt_keep_natts_fast, wstate->index, dstate->base,
+							   itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
+
+#endif
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index 241e26d338..8e5337cad7 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -692,7 +692,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	{
 		itemid = PageGetItemId(state->origpage, maxoff);
 		tup = (IndexTuple) PageGetItem(state->origpage, itemid);
-		keepnatts = _bt_keep_natts_fast(state->rel, tup, state->newitem);
+		keepnatts = nbts_call(_bt_keep_natts_fast, state->rel, tup, state->newitem);
 
 		if (keepnatts > 1 && keepnatts <= nkeyatts)
 		{
@@ -723,7 +723,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 		!_bt_adjacenthtid(&tup->t_tid, &state->newitem->t_tid))
 		return false;
 	/* Check same conditions as rightmost item case, too */
-	keepnatts = _bt_keep_natts_fast(state->rel, tup, state->newitem);
+	keepnatts = nbts_call(_bt_keep_natts_fast, state->rel, tup, state->newitem);
 
 	if (keepnatts > 1 && keepnatts <= nkeyatts)
 	{
@@ -972,7 +972,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 	 * avoid appending a heap TID in new high key, we're done.  Finish split
 	 * with default strategy and initial split interval.
 	 */
-	perfectpenalty = _bt_keep_natts_fast(state->rel, leftmost, rightmost);
+	perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, leftmost, rightmost);
 	if (perfectpenalty <= indnkeyatts)
 		return perfectpenalty;
 
@@ -993,7 +993,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 	 * If page is entirely full of duplicates, a single value strategy split
 	 * will be performed.
 	 */
-	perfectpenalty = _bt_keep_natts_fast(state->rel, leftmost, rightmost);
+	perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, leftmost, rightmost);
 	if (perfectpenalty <= indnkeyatts)
 	{
 		*strategy = SPLIT_MANY_DUPLICATES;
@@ -1031,8 +1031,8 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 
 		itemid = PageGetItemId(state->origpage, P_HIKEY);
 		hikey = (IndexTuple) PageGetItem(state->origpage, itemid);
-		perfectpenalty = _bt_keep_natts_fast(state->rel, hikey,
-											 state->newitem);
+		perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, hikey,
+								   state->newitem);
 		if (perfectpenalty <= indnkeyatts)
 			*strategy = SPLIT_SINGLE_VALUE;
 		else
@@ -1154,7 +1154,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 	lastleft = _bt_split_lastleft(state, split);
 	firstright = _bt_split_firstright(state, split);
 
-	return _bt_keep_natts_fast(state->rel, lastleft, firstright);
+	return nbts_call(_bt_keep_natts_fast, state->rel, lastleft, firstright);
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index ff260c393a..bc443ebd27 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,11 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1221,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1704,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
new file mode 100644
index 0000000000..a4b934ae7a
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.h
@@ -0,0 +1,772 @@
+/*
+ * Specialized functions included in nbtutils.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static bool NBTS_FUNCTION(_bt_check_rowcompare)(ScanKey skey,
+												IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+												ScanDirection dir, bool *continuescan);
+
+static int	NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
+										  IndexTuple firstright, BTScanInsert itup_key);
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+NBTS_FUNCTION(_bt_check_rowcompare)(ScanKey skey, IndexTuple tuple,
+									int tupnatts, TupleDesc tupdesc,
+									ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
+							  IndexTuple firstright, BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == nbts_call(_bt_keep_natts_fast, rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+#endif /* NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+NBTS_FUNCTION(_bt_checkkeys)(Relation rel, IndexScanDesc scan,
+							 IndexTuple tuple, int tupnatts,
+							 ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (nbts_call_norel(_bt_check_rowcompare, rel, key, tuple,
+								tupnatts, tupdesc, dir, continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+NBTS_FUNCTION(_bt_truncate)(Relation rel, IndexTuple lastleft,
+							IndexTuple firstright, BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = nbts_call(_bt_keep_natts, rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel,
+								   IndexTuple lastleft,
+								   IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 1174e1a31c..816165217e 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -1122,7 +1122,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 
 	state->tupDesc = tupDesc;	/* assume we need not copy tupDesc */
 
-	indexScanKey = _bt_mkscankey(indexRel, NULL);
+	indexScanKey = nbts_call(_bt_mkscankey, indexRel, NULL);
 
 	if (state->indexInfo->ii_Expressions != NULL)
 	{
@@ -1220,7 +1220,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	state->enforceUnique = enforceUnique;
 	state->uniqueNullsNotDistinct = uniqueNullsNotDistinct;
 
-	indexScanKey = _bt_mkscankey(indexRel, NULL);
+	indexScanKey = nbts_call(_bt_mkscankey, indexRel, NULL);
 
 	/* Prepare SortSupport data for each column */
 	state->sortKeys = (SortSupport) palloc0(state->nKeys *
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 93f8267b48..83e0dbab16 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1116,15 +1116,47 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+
+
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define NBTS_ENABLED
+
+#ifdef NBTS_ENABLED
+
+/*
+ * Access a specialized nbtree function, based on the shape of the index key.
+ */
+
+#define NBT_SPECIALIZE_CALL(function, rel, ...) \
+( \
+	NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+)
+
+#else /* not defined NBTS_ENABLED */
+
+#define NBT_SPECIALIZE_CALL(function, rel, ...) function(__VA_ARGS__)
+
+#endif /* NBTS_ENABLED */
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specialized.h"
+#include "nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1155,9 +1187,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
-						   IndexTuple newitem, Size newitemsz,
-						   bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1173,9 +1202,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Buffer lbuf, BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, BTStack stack, BlockNumber child);
 
@@ -1223,12 +1249,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
-						  int access, Snapshot snapshot);
-extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
@@ -1237,7 +1257,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1245,8 +1264,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1259,10 +1276,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
new file mode 100644
index 0000000000..23fdda4f0e
--- /dev/null
+++ b/src/include/access/nbtree_specialize.h
@@ -0,0 +1,204 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_call(function, indexrel, ...rest_of_args), and
+ *   nbts_call_norel(function, indexrel, ...args)
+ *     This will call the specialized variant of 'function' based on the index
+ *     relation data.
+ *     The difference between nbts_call and nbts_call_norel is that _call
+ *     uses indexrel as first argument in the function call, whereas
+ *     nbts_call_norel does not.
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ *
+ * example usage:
+ *
+ * kwithnulls = nbts_call_norel(_bt_key_hasnulls, myindex, mytuple, tupDesc);
+ *
+ * NBTS_FUNCTION(_bt_key_hasnulls)(IndexTuple mytuple, TupleDesc tupDesc)
+ * {
+ *    nbts_attiterdeclare(mytuple);
+ *    nbts_attiterinit(mytuple, 1, tupDesc);
+ *    nbts_foreachattr(1, 10)
+ *    {
+ *        Datum it = nbts_attiter_nextattdatum(tuple, tupDesc);
+ *        if (nbts_attiter_curattisnull(tuple))
+ *           return true;
+ *    }
+ *    return false
+ * }
+ */
+
+/*
+ * Call a potentially specialized function for a given btree operation.
+ *
+ * NB: the rel argument is evaluated multiple times.
+ */
+#define nbts_call(name, rel, ...) \
+	nbts_call_norel(name, (rel), (rel), __VA_ARGS__)
+
+#ifdef NBTS_ENABLED
+
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+#ifdef nbts_call_norel
+#undef nbts_call_norel
+#endif
+
+#define nbts_call_norel(name, rel, ...) \
+	(NBTS_FUNCTION(name)(__VA_ARGS__))
+
+/*
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_CACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/* reset call to SPECIALIZE_CALL for default behaviour */
+#undef nbts_call_norel
+#define nbts_call_norel(name, rel, ...) \
+	NBT_SPECIALIZE_CALL(name, (rel), __VA_ARGS__)
+
+/*
+ * "Default", externally accessible, not so much optimized functions
+ */
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+/* for the default functions, we want to use the unspecialized name. */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) name
+
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/* from here on there are no more NBTS_FUNCTIONs */
+#undef NBTS_FUNCTION
+
+#else /* not defined NBTS_ENABLED */
+
+/*
+ * NBTS_ENABLE is not defined, so we don't want to use the specializations.
+ * We revert to the behaviour from PG14 and earlier, which only uses
+ * attcacheoff.
+ */
+
+#define NBTS_FUNCTION(name) name
+
+#define nbts_call_norel(name, rel, ...) \
+	name(__VA_ARGS__)
+
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+
+#endif /* !NBTS_ENABLED */
diff --git a/src/include/access/nbtree_specialized.h b/src/include/access/nbtree_specialized.h
new file mode 100644
index 0000000000..c45fa84aed
--- /dev/null
+++ b/src/include/access/nbtree_specialized.h
@@ -0,0 +1,67 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void
+NBTS_FUNCTION(_bt_specialize)(Relation rel);
+
+extern bool
+NBTS_FUNCTION(btinsert)(Relation rel, Datum *values, bool *isnull,
+						ItemPointer ht_ctid, Relation heapRel,
+						IndexUniqueCheck checkUnique,
+						bool indexUnchanged,
+						struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void
+NBTS_FUNCTION(_bt_dedup_pass)(Relation rel, Buffer buf, Relation heapRel,
+							  IndexTuple newitem, Size newitemsz,
+							  bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool
+NBTS_FUNCTION(_bt_doinsert)(Relation rel, IndexTuple itup,
+							IndexUniqueCheck checkUnique, bool indexUnchanged,
+							Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack
+NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key,
+						  Buffer *bufP, int access,
+						  Snapshot snapshot);
+extern Buffer
+NBTS_FUNCTION(_bt_moveright)(Relation rel, BTScanInsert key, Buffer buf,
+							 bool forupdate, BTStack stack, int access,
+							 Snapshot snapshot);
+extern OffsetNumber
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate);
+extern int32
+NBTS_FUNCTION(_bt_compare)(Relation rel, BTScanInsert key,
+						   Page page, OffsetNumber offnum);
+
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert
+NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup);
+extern bool
+NBTS_FUNCTION(_bt_checkkeys)(Relation rel, IndexScanDesc scan,
+							 IndexTuple tuple, int tupnatts,
+							 ScanDirection dir, bool *continuescan);
+extern IndexTuple
+NBTS_FUNCTION(_bt_truncate)(Relation rel, IndexTuple lastleft,
+							IndexTuple firstright, BTScanInsert itup_key);
+extern int
+NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel, IndexTuple lastleft,
+								   IndexTuple firstright);
-- 
2.30.2

From 8cc1ea41353ba0d0d69a6383c75ed2663608d609 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 7 Apr 2022 12:30:00 +0200
Subject: [PATCH v3 2/9] Use specialized attribute iterators in
 backend/*/nbt*_spec.h

Split out for making it clear what substantial changes were made to the
pre-existing functions.

Even though not all nbt*_spec functions have been updated; most call sites
now can directly call the specialized functions instead of having to determine
the right specialization based on the (potentially locally unavailable) index
relation, making the specialization of those functions worth the effort.
---
 src/backend/access/nbtree/nbtsearch_spec.h | 16 +++---
 src/backend/access/nbtree/nbtsort_spec.h   | 24 +++++----
 src/backend/access/nbtree/nbtutils_spec.h  | 63 +++++++++++++---------
 3 files changed, 62 insertions(+), 41 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
index 73d5370496..a5c5f2b94f 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.h
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -823,6 +823,7 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -854,23 +855,26 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
diff --git a/src/backend/access/nbtree/nbtsort_spec.h b/src/backend/access/nbtree/nbtsort_spec.h
index 8f4a3602ca..d3f2db2dc4 100644
--- a/src/backend/access/nbtree/nbtsort_spec.h
+++ b/src/backend/access/nbtree/nbtsort_spec.h
@@ -27,8 +27,7 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -50,7 +49,7 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -82,22 +81,25 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 			}
 			else if (itup != NULL)
 			{
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 				int32		compare = 0;
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
index a4b934ae7a..638eff18f6 100644
--- a/src/backend/access/nbtree/nbtutils_spec.h
+++ b/src/backend/access/nbtree/nbtutils_spec.h
@@ -211,6 +211,8 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -222,20 +224,22 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -243,6 +247,7 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -295,7 +300,7 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -326,7 +331,10 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -337,27 +345,30 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -744,24 +755,28 @@ NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft,itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) !=
+			nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
-- 
2.30.2

From 38f619c26422ff8b58f6f70478ba110401f53ee0 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 7 Apr 2022 12:47:50 +0200
Subject: [PATCH v3 4/9] Optimize attribute iterator access for single-column
 btree keys

This removes the index_getattr_nocache call path, which has significant overhead.
---
 src/include/access/nbtree.h            |  9 ++++-
 src/include/access/nbtree_specialize.h | 56 ++++++++++++++++++++++++++
 2 files changed, 64 insertions(+), 1 deletion(-)

diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 489b623663..1559399b0e 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1120,6 +1120,7 @@ typedef struct BTOptions
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_COLUMN single
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 
@@ -1151,7 +1152,13 @@ do { \
 
 #define NBT_SPECIALIZE_CALL(function, rel, ...) \
 ( \
-	NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? (   \
+		NBTS_MAKE_NAME(function, NBTS_TYPE_SINGLE_COLUMN)(__VA_ARGS__) \
+	) \
+	: \
+	( \
+		NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+	) \
 )
 
 #else /* not defined NBTS_ENABLED */
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
index 23fdda4f0e..642bc4c795 100644
--- a/src/include/access/nbtree_specialize.h
+++ b/src/include/access/nbtree_specialize.h
@@ -79,6 +79,62 @@
 #define nbts_call_norel(name, rel, ...) \
 	(NBTS_FUNCTION(name)(__VA_ARGS__))
 
+/*
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path may never be used for indexes with multiple key
+ *  columns, because it does not ever continue to a next column.
+ */
+
+#define NBTS_SPECIALIZING_SINGLE_COLUMN
+#define NBTS_TYPE NBTS_TYPE_SINGLE_COLUMN
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+/*
+ * Simplified (optimized) variant of index_getattr specialized for extracting
+ * only the first attribute: cache offset is guaranteed to be 0, and as such
+ * no cache is required.
+ */
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	(IndexTupleHasNulls(itup) && att_isnull(0, (char *)(itup) + sizeof(IndexTupleData))) ? \
+	( \
+		(NBTS_MAKE_NAME(itup, isNull)) = true, \
+		(Datum)NULL \
+	) \
+	: \
+	( \
+		(NBTS_MAKE_NAME(itup, isNull) = false), \
+		(Datum) fetchatt(TupleDescAttr((tupDesc), 0), \
+		(char *) (itup) + IndexInfoFindDataOffset((itup)->t_info)) \
+	) \
+)
+
+#define nbts_attiter_curattisnull(tuple) \
+	NBTS_MAKE_NAME(tuple, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_COLUMN
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
  */
-- 
2.30.2

From 7cd7335a8e0c0540835a738ad92dc6c214ebe566 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:51:01 +0200
Subject: [PATCH v3 5/9] Add a function whose task it is to populate all
 attcacheoff-s of a TupleDesc's attributes

It fills uncacheable offsets with -2; as opposed to -1 which signals
"unknown", thus allowing users of the API to determine the cache-ability
of an attribute at O(1) complexity after this one-time O(n) cost, as
opposed to the repeated O(n) cost that currently applies.
---
 src/backend/access/common/tupdesc.c | 97 +++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |  2 +
 2 files changed, 99 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 9f41b1e854..5630fc9da0 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -910,3 +910,100 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid value.
+ *
+ * Sets attcacheoff to -2 for uncacheable attributes (i.e. attributes after a
+ * variable length attributes).
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	i, j;
+
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+	{
+		/*
+		 * Already done the calculations, find the last attribute that has
+		 * cache offset.
+		 */
+		for (i = (AttrNumber) numberOfAttributes; i > 1; i--)
+		{
+			if (TupleDescAttr(desc, i - 1)->attcacheoff != -2)
+				return i;
+		}
+
+		return 1;
+	}
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	i = 1;
+	/*
+	 * Someone might have set some offsets previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (i < numberOfAttributes && TupleDescAttr(desc, i)->attcacheoff > 0)
+		i++;
+
+	/* Cache offset is undetermined. Start calculating offsets if possible */
+	if (i < numberOfAttributes &&
+		TupleDescAttr(desc, i)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, i - 1);
+		Size off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (i < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, i);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+						att->attcacheoff = off;
+					else
+						att->attcacheoff = -2;
+					i++;
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				i++;
+			}
+		} else {
+			if (off == att_align_nominal(off, att->attalign))
+				att->attcacheoff = off;
+			else
+				att->attcacheoff = -2;
+			i++;
+		}
+	}
+
+	/*
+	 * No cacheable offsets left. Fill the rest with -2s, but return the latest
+	 * cached offset.
+	 */
+	j = i;
+
+	while (i < numberOfAttributes)
+	{
+		TupleDescAttr(desc, i)->attcacheoff = -2;
+		i++;
+	}
+
+	return j;
+}
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index 28dd6de18b..219f837875 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.30.2

From 8caee4fa759430b4f1ea5e6ca6cff8ea0f67bb80 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 21 Apr 2022 16:22:07 +0200
Subject: [PATCH v3 8/9] Add specialization to btree index creation.

This was an oversight that is corrected easily; but an oversight nonetheless.
This increases the (re)build performance of indexes by another few percents.
---
 src/backend/utils/sort/tuplesort.c      | 147 ++---------------------
 src/backend/utils/sort/tuplesort_nbts.h | 148 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  18 +++
 3 files changed, 175 insertions(+), 138 deletions(-)
 create mode 100644 src/backend/utils/sort/tuplesort_nbts.h

diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 816165217e..8adc734f1c 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -651,8 +651,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int len);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static void copytup_index(Tuplesortstate *state, SortTuple *stup, void *tup);
@@ -675,6 +673,10 @@ static void free_sort_tuple(Tuplesortstate *state, SortTuple *stup);
 static void tuplesort_free(Tuplesortstate *state);
 static void tuplesort_updatemax(Tuplesortstate *state);
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesort_nbts.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
 /*
  * Specialized comparators that we can inline into specialized sorts.  The goal
  * is to try to sort two tuples without having to follow the pointers to the
@@ -1208,7 +1210,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 								sortopt & TUPLESORT_RANDOMACCESS,
 								PARALLEL_SORT(state));
 
-	state->comparetup = comparetup_index_btree;
+	state->comparetup = NBT_SPECIALIZE_NAME(comparetup_index_btree, indexRel);
 	state->copytup = copytup_index;
 	state->writetup = writetup_index;
 	state->readtup = readtup_index;
@@ -1326,7 +1328,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 
 	state->nKeys = IndexRelationGetNumberOfKeyAttributes(indexRel);
 
-	state->comparetup = comparetup_index_btree;
+	state->comparetup = NBT_SPECIALIZE_NAME(comparetup_index_btree, indexRel);
 	state->copytup = copytup_index;
 	state->writetup = writetup_index;
 	state->readtup = readtup_index;
@@ -4292,142 +4294,11 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
  * The btree and hash cases require separate comparison functions, but the
  * IndexTuple representation is the same so the copy/write/read support
  * functions can be shared.
+ *
+ * nbtree function can be found in tuplesort_nbts.h, and is included
+ * through the nbtree specialization functions.
  */
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	SortSupport sortKey = state->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = state->nKeys;
-	tupDes = RelationGetDescr(state->indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (state->enforceUnique && !(!state->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(state->indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(state->indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(state->heapRel,
-									RelationGetRelationName(state->indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesort_nbts.h b/src/backend/utils/sort/tuplesort_nbts.h
new file mode 100644
index 0000000000..d1b2670747
--- /dev/null
+++ b/src/backend/utils/sort/tuplesort_nbts.h
@@ -0,0 +1,148 @@
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static int NBTS_FUNCTION(comparetup_index_btree)(const SortTuple *a,
+												 const SortTuple *b,
+												 Tuplesortstate *state);
+
+static int
+NBTS_FUNCTION(comparetup_index_btree)(const SortTuple *a, const SortTuple *b,
+									  Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	SortSupport sortKey = state->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = state->nKeys;
+	tupDes = RelationGetDescr(state->indexRel);
+
+	if (!sortKey->abbrev_converter)
+	{
+		nkey = 2;
+		sortKey++;
+	}
+	else
+		nkey = 1;
+
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
+	{
+		Datum		datum1,
+					datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+		{
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		}
+		else
+		{
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
+		}
+
+		if (compare != 0)
+			return compare;
+
+		if (nbts_attiter_curattisnull(tuple1))
+			equal_hasnull = true;
+
+		sortKey++;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (state->enforceUnique && !(!state->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(state->indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(state->indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(state->heapRel,
+									   RelationGetRelationName(state->indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
+
+#endif
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 80f2575884..3e291c84fd 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1169,6 +1169,24 @@ do { \
 	) \
 )
 
+#define NBT_SPECIALIZE_NAME(name, rel) \
+( \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_COLUMN) \
+	) \
+	: \
+	( \
+		TupleDescAttr(RelationGetDescr(rel), \
+					  IndexRelationGetNumberOfKeyAttributes(rel) - 1)->attcacheoff > 0 ? ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+		) \
+		: \
+		( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED) \
+		) \
+	) \
+)
+
 #else /* not defined NBTS_ENABLED */
 
 #define nbt_opt_specialize(rel)
-- 
2.30.2

From 4f8c9cb8af171fca3226ef9acb2883623576983d Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 15 Apr 2022 18:25:38 +0200
Subject: [PATCH v3 7/9] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the scan attributes
on both sides of the compared tuple are equal to the scankey, then the current
tuple that is being compared must also have those prefixing attributes that
equal the scankey.

We cannot propagate this information to _binsrch on lower pages, as this
downstream page may concurrently have split and/or have merged with its
deleted left neighbour (see [0]), which moves the keyspace of the linked page.
We thus can only trust the current state of this current page for this
optimization, which means we must validate this state each time we open the
page.

Although this limits the overall performance improvement, it still allows
for a nice performance improvement in most cases where initial columns have
many duplicate values and a compare function that is not cheap.
---
 contrib/amcheck/verify_nbtree.c            | 17 +++--
 src/backend/access/nbtree/README           | 25 ++++++++
 src/backend/access/nbtree/nbtinsert.c      | 14 ++--
 src/backend/access/nbtree/nbtinsert_spec.h | 22 +++++--
 src/backend/access/nbtree/nbtsearch.c      |  2 +-
 src/backend/access/nbtree/nbtsearch_spec.h | 75 +++++++++++++++++-----
 src/include/access/nbtree_specialized.h    |  8 ++-
 7 files changed, 127 insertions(+), 36 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 70278c4f93..5753611546 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2673,6 +2673,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2682,13 +2683,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2750,6 +2751,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2760,7 +2762,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2812,10 +2814,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2835,10 +2838,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2873,13 +2877,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 3c08888c23..13ac9ee2be 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,31 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+potentially saving cycles.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by an inner page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. (2,2) to (1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+The positive part of this, is that we already have results of the highest
+value of a page: a pages' highkey is compared to the scankey while we have
+a pin on the page in the _bt_moveright procedure. The _bt_binsrch procedure
+will use this result as a rightmost prefix compare, and for each step in the
+binary search (that does not compare less than the insert key) improve the
+equal-prefix bounds.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index ec6c73d1cc..20e5f33f98 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -132,7 +132,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = nbts_call(_bt_binsrch_insert, rel, insertstate);
+	offset = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -142,6 +142,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -177,7 +179,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset) < 0);
+				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset,
+								 &cmpcol) < 0);
 				break;
 			}
 
@@ -202,7 +205,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (nbts_call(_bt_compare, rel, itup_key, page, offset) != 0)
+					if (nbts_call(_bt_compare, rel, itup_key, page, offset,
+								  &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -412,11 +416,13 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY);
+			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY,
+								   &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
diff --git a/src/backend/access/nbtree/nbtinsert_spec.h b/src/backend/access/nbtree/nbtinsert_spec.h
index 97c866aea3..ccba0fa5ed 100644
--- a/src/backend/access/nbtree/nbtinsert_spec.h
+++ b/src/backend/access/nbtree/nbtinsert_spec.h
@@ -73,6 +73,7 @@ NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	comparecol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -91,7 +92,8 @@ NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				nbts_call(_bt_compare, rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				nbts_call(_bt_compare, rel, insertstate->itup_key, page,
+						  P_HIKEY, &comparecol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -221,6 +223,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -238,7 +241,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0)
+					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, insertstate, stack);
@@ -291,6 +294,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -321,7 +325,8 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) != 0 ||
+				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY,
+						  &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -336,10 +341,13 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) || nbts_call(_bt_compare, rel, itup_key,
+												page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -358,7 +366,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index d5152bfcb7..036ce88679 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -696,7 +696,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf);
+	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf, 1);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
index a5c5f2b94f..829c216819 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.h
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -10,8 +10,10 @@
  */
 #ifndef NBTS_SPECIALIZING_DEFAULT
 
-static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel, BTScanInsert key,
-											   Buffer buf);
+static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel,
+											   BTScanInsert key,
+											   Buffer buf,
+											   AttrNumber highkeycmpcol);
 static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
 										OffsetNumber offnum);
 
@@ -38,7 +40,8 @@ static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
 static OffsetNumber
 NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 						   BTScanInsert key,
-						   Buffer buf)
+						   Buffer buf,
+						   AttrNumber highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -46,6 +49,8 @@ NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	AttrNumber	highcmpcol = highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -87,15 +92,22 @@ NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = nbts_call(_bt_compare, rel, key, page, mid);
+		result = nbts_call(_bt_compare, rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
 
 	/*
@@ -441,6 +453,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		IndexTuple	itup;
 		BlockNumber child;
 		BTStack		new_stack;
+		AttrNumber	highkeycmpcol = 1;
 
 		/*
 		 * Race -- the page we just grabbed may have split since we read its
@@ -456,7 +469,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 */
 		*bufP = nbts_call(_bt_moveright, rel, key, *bufP,
 						  (access == BT_WRITE), stack_in,
-						  page_access, snapshot);
+						  page_access, snapshot, &highkeycmpcol);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -468,7 +481,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = nbts_call(_bt_binsrch, rel, key, *bufP);
+		offnum = nbts_call(_bt_binsrch, rel, key, *bufP, highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
@@ -507,6 +520,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		AttrNumber highkeycmpcol = 1;
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -517,7 +531,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = nbts_call(_bt_moveright, rel, key, *bufP, true, stack_in,
-						  BT_WRITE, snapshot);
+						  BT_WRITE, snapshot, &highkeycmpcol);
 	}
 
 	return stack_in;
@@ -565,12 +579,15 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 							 bool forupdate,
 							 BTStack stack,
 							 int access,
-							 Snapshot snapshot)
+							 Snapshot snapshot,
+							 AttrNumber *comparecol)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
+	Assert(PointerIsValid(comparecol));
+
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
 	 * this page is > the high key stored on the page, then the page has split
@@ -592,12 +609,17 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -623,14 +645,19 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY) >= cmpval)
+		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY,
+										  &cmpcol) >= cmpval)
 		{
 			/* step right one page */
+			*comparecol = 1;
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -663,7 +690,8 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
  * list split).
  */
 OffsetNumber
-NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate,
+								  AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -673,6 +701,7 @@ NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -723,16 +752,21 @@ NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = nbts_call(_bt_compare, rel, key, page, mid);
+		result = nbts_call(_bt_compare, rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -813,7 +847,8 @@ int32
 NBTS_FUNCTION(_bt_compare)(Relation rel,
 						   BTScanInsert key,
 						   Page page,
-						   OffsetNumber offnum)
+						   OffsetNumber offnum,
+						   AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -854,10 +889,11 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	nbts_attiterinit(itup, 1, itupdesc);
 
-	nbts_foreachattr(1, ncmpkey)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+	scankey = key->scankeys + ((*comparecol) - 1);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
 
@@ -902,11 +938,20 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = nbts_attiter_attnum;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
diff --git a/src/include/access/nbtree_specialized.h b/src/include/access/nbtree_specialized.h
index c45fa84aed..7402a4c46e 100644
--- a/src/include/access/nbtree_specialized.h
+++ b/src/include/access/nbtree_specialized.h
@@ -43,12 +43,14 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key,
 extern Buffer
 NBTS_FUNCTION(_bt_moveright)(Relation rel, BTScanInsert key, Buffer buf,
 							 bool forupdate, BTStack stack, int access,
-							 Snapshot snapshot);
+							 Snapshot snapshot, AttrNumber *comparecol);
 extern OffsetNumber
-NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate);
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate,
+								  AttrNumber highcmpcol);
 extern int32
 NBTS_FUNCTION(_bt_compare)(Relation rel, BTScanInsert key,
-						   Page page, OffsetNumber offnum);
+						   Page page, OffsetNumber offnum,
+						   AttrNumber *comparecol);
 
 /*
  * prototypes for functions in nbtutils_spec.h
-- 
2.30.2

From b33ff609d10ed1ab9925cb128f05d05cc5babb46 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:44:01 +0200
Subject: [PATCH v3 6/9] Implement specialized uncacheable attribute iteration

Uses an iterator to prevent doing duplicate work while iterating over
attributes.

Inspiration: https://www.postgresql.org/message-id/CAEze2WjE9ka8i%3Ds-Vv5oShro9xTrt5VQnQvFG9AaRwWpMm3-fg%40mail.gmail.com
---
 src/backend/access/nbtree/nbtree_spec.h |   1 +
 src/include/access/itup.h               | 179 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  12 +-
 src/include/access/nbtree_specialize.h  |  34 +++++
 4 files changed, 224 insertions(+), 2 deletions(-)

diff --git a/src/backend/access/nbtree/nbtree_spec.h b/src/backend/access/nbtree/nbtree_spec.h
index 4c342287f6..88b01c86f7 100644
--- a/src/backend/access/nbtree/nbtree_spec.h
+++ b/src/backend/access/nbtree/nbtree_spec.h
@@ -9,6 +9,7 @@ void
 NBTS_FUNCTION(_bt_specialize)(Relation rel)
 {
 #ifdef NBTS_SPECIALIZING_DEFAULT
+	PopulateTupleDescCacheOffsets(rel->rd_att);
 	nbts_call_norel(_bt_specialize, rel, rel);
 #else
 	rel->rd_indam->aminsert = NBTS_FUNCTION(btinsert);
diff --git a/src/include/access/itup.h b/src/include/access/itup.h
index 2c8877e991..cc29614107 100644
--- a/src/include/access/itup.h
+++ b/src/include/access/itup.h
@@ -59,6 +59,15 @@ typedef struct IndexAttributeBitMapData
 
 typedef IndexAttributeBitMapData * IndexAttributeBitMap;
 
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
 /*
  * t_info manipulation macros
  */
@@ -126,6 +135,42 @@ typedef IndexAttributeBitMapData * IndexAttributeBitMap;
 	) \
 )
 
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
 /*
  * MaxIndexTuplesPerPage is an upper bound on the number of tuples that can
  * fit on one index page.  An index tuple must have either data or a null
@@ -161,4 +206,138 @@ extern IndexTuple CopyIndexTuple(IndexTuple source);
 extern IndexTuple index_truncate_tuple(TupleDesc sourceDescriptor,
 									   IndexTuple source, int leavenatts);
 
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
 #endif							/* ITUP_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 1559399b0e..80f2575884 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1122,6 +1122,7 @@ typedef struct BTOptions
  */
 #define NBTS_TYPE_SINGLE_COLUMN single
 #define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_DEFAULT default
 
 
@@ -1152,12 +1153,19 @@ do { \
 
 #define NBT_SPECIALIZE_CALL(function, rel, ...) \
 ( \
-	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? (   \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? ( \
 		NBTS_MAKE_NAME(function, NBTS_TYPE_SINGLE_COLUMN)(__VA_ARGS__) \
 	) \
 	: \
 	( \
-		NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+		TupleDescAttr(RelationGetDescr(rel), \
+					  IndexRelationGetNumberOfKeyAttributes(rel) - 1)->attcacheoff > 0 ? ( \
+			NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+		) \
+		: \
+		( \
+			NBTS_MAKE_NAME(function, NBTS_TYPE_UNCACHED)(__VA_ARGS__) \
+		) \
 	) \
 )
 
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
index 642bc4c795..52739d390e 100644
--- a/src/include/access/nbtree_specialize.h
+++ b/src/include/access/nbtree_specialize.h
@@ -168,6 +168,40 @@
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /* reset call to SPECIALIZE_CALL for default behaviour */
 #undef nbts_call_norel
 #define nbts_call_norel(name, rel, ...) \
-- 
2.30.2

From 595370bc49043fa2413e62c3b4b4573af2ef5f61 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Sun, 30 Jan 2022 16:23:31 +0100
Subject: [PATCH v4 1/8] Specialize nbtree functions on btree key shape

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, initially splitting splitting out
(not yet: specializing) the attcacheoff-capable case.

Note that we generate N specialized functions and 1 'default' function for each
specializable function.

This feature can be disabled by removing the #define NBTS_ENABLED -line in nbtree.h
---
 src/backend/access/nbtree/README           |  22 +
 src/backend/access/nbtree/nbtdedup.c       | 300 +------
 src/backend/access/nbtree/nbtdedup_spec.h  | 313 +++++++
 src/backend/access/nbtree/nbtinsert.c      | 572 +-----------
 src/backend/access/nbtree/nbtinsert_spec.h | 569 ++++++++++++
 src/backend/access/nbtree/nbtpage.c        |   4 +-
 src/backend/access/nbtree/nbtree.c         |  31 +-
 src/backend/access/nbtree/nbtree_spec.h    |  50 ++
 src/backend/access/nbtree/nbtsearch.c      | 994 +--------------------
 src/backend/access/nbtree/nbtsearch_spec.h | 994 +++++++++++++++++++++
 src/backend/access/nbtree/nbtsort.c        | 271 +-----
 src/backend/access/nbtree/nbtsort_spec.h   | 275 ++++++
 src/backend/access/nbtree/nbtsplitloc.c    |  14 +-
 src/backend/access/nbtree/nbtutils.c       | 755 +---------------
 src/backend/access/nbtree/nbtutils_spec.h  | 772 ++++++++++++++++
 src/backend/utils/sort/tuplesort.c         |   4 +-
 src/include/access/nbtree.h                |  61 +-
 src/include/access/nbtree_specialize.h     | 204 +++++
 src/include/access/nbtree_specialized.h    |  67 ++
 19 files changed, 3357 insertions(+), 2915 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.h
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.h
 create mode 100644 src/backend/access/nbtree/nbtree_spec.h
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.h
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.h
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.h
 create mode 100644 src/include/access/nbtree_specialize.h
 create mode 100644 src/include/access/nbtree_specialized.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 5529afc1fe..3c08888c23 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1041,6 +1041,28 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+
+Notes about nbtree call specialization
+--------------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes.
+We can avoid it by specializing performance-sensitive search functions
+and calling those selectively.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.  This performance benefit is at the cost
+of binary size, so this feature can be disabled by defining NBTS_DISABLED.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - single-column indexes
+   NB: The code paths of this optimization do not support multiple key columns.
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also used for the default case, and is slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 0207421a5d..d7025d8e1c 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,259 +22,16 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
-			   Size newitemsz, bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple, and actually update the page.  Else
-			 * reset the state and move on without modifying the page.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
 
 /*
  * Perform bottom-up index deletion pass.
@@ -373,7 +130,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 			/* itup starts first pending interval */
 			_bt_dedup_start_pending(state, itup, offnum);
 		}
-		else if (_bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+		else if (nbts_call(_bt_keep_natts_fast, rel, state->base, itup) > nkeyatts &&
 				 _bt_dedup_save_htid(state, itup))
 		{
 			/* Tuple is equal; just added its TIDs to pending interval */
@@ -748,55 +505,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.h b/src/backend/access/nbtree/nbtdedup_spec.h
new file mode 100644
index 0000000000..27e5a7e686
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.h
@@ -0,0 +1,313 @@
+/*
+ * Specialized functions included in nbtdedup.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static bool NBTS_FUNCTION(_bt_do_singleval)(Relation rel, Page page, BTDedupState state,
+											OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+NBTS_FUNCTION(_bt_do_singleval)(Relation rel, Page page, BTDedupState state,
+								OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (nbts_call(_bt_keep_natts_fast, rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (nbts_call(_bt_keep_natts_fast, rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
+
+#endif /* ifndef NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+NBTS_FUNCTION(_bt_dedup_pass)(Relation rel, Buffer buf, Relation heapRel,
+							  IndexTuple newitem, Size newitemsz,
+							  bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				 minoff,
+				 maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = nbts_call(_bt_do_singleval, rel, page, state,
+								   minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 nbts_call(_bt_keep_natts_fast, rel, state->base, itup) > nkeyatts &&
+						   _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple, and actually update the page.  Else
+			 * reset the state and move on without modifying the page.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index f6f4af8bfe..ec6c73d1cc 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,18 +30,13 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
-static void _bt_stepright(Relation rel, BTInsertState insertstate, BTStack stack);
+static void _bt_stepright(Relation rel,
+										 BTInsertState insertstate,
+										 BTStack stack);
 static void _bt_insertonpg(Relation rel, BTScanInsert itup_key,
 						   Buffer buf,
 						   Buffer cbuf,
@@ -73,311 +68,10 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
-					   itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
-					  NULL);
-}
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -438,7 +132,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = nbts_call(_bt_binsrch_insert, rel, insertstate);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -483,7 +177,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset) < 0);
 				break;
 			}
 
@@ -508,7 +202,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (nbts_call(_bt_compare, rel, itup_key, page, offset) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -722,7 +416,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -769,246 +463,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
-					break;
-
-				_bt_stepright(rel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1649,7 +1103,7 @@ _bt_split(Relation rel, BTScanInsert itup_key, Buffer buf, Buffer cbuf,
 				lastleft = nposting;
 		}
 
-		lefthighkey = _bt_truncate(rel, lastleft, firstright, itup_key);
+		lefthighkey = nbts_call(_bt_truncate, rel, lastleft, firstright, itup_key);
 		itemsz = IndexTupleSize(lefthighkey);
 	}
 	else
@@ -2764,8 +2218,8 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 
 	/* Perform deduplication pass (when enabled and index-is-allequalimage) */
 	if (BTGetDeduplicateItems(rel) && itup_key->allequalimage)
-		_bt_dedup_pass(rel, buffer, heapRel, insertstate->itup,
-					   insertstate->itemsz, (indexUnchanged || uniquedup));
+		nbts_call(_bt_dedup_pass, rel, buffer, heapRel, insertstate->itup,
+				  insertstate->itemsz, (indexUnchanged || uniquedup));
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtinsert_spec.h b/src/backend/access/nbtree/nbtinsert_spec.h
new file mode 100644
index 0000000000..97c866aea3
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.h
@@ -0,0 +1,569 @@
+/*
+ * Specialized functions for nbtinsert.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static BTStack NBTS_FUNCTION(_bt_search_insert)(Relation rel,
+												BTInsertState insertstate);
+
+static OffsetNumber NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
+													 BTInsertState insertstate,
+													 bool checkingunique,
+													 bool indexUnchanged,
+													 BTStack stack,
+													 Relation heapRel);
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				nbts_call(_bt_compare, rel, insertstate->itup_key, page, P_HIKEY) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return nbts_call(_bt_search, rel, insertstate->itup_key,
+					 &insertstate->buf, BT_WRITE, NULL);
+}
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
+								 BTInsertState insertstate,
+								 bool checkingunique,
+								 bool indexUnchanged,
+								 BTStack stack,
+								 Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0)
+					break;
+
+				_bt_stepright(rel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	Assert(P_RIGHTMOST(opaque) ||
+		   nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0);
+
+	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
+
+#endif /* ifndef NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+NBTS_FUNCTION(_bt_doinsert)(Relation rel, IndexTuple itup,
+							IndexUniqueCheck checkUnique,
+							bool indexUnchanged,
+							Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = nbts_call(_bt_mkscankey, rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = nbts_call(_bt_search_insert, rel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = nbts_call(_bt_findinsertloc, rel, &insertstate, checkingunique,
+							   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
+					   itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 20adb602a4..e66299ebd8 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1967,10 +1967,10 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 				}
 
 				/* we need an insertion scan key for the search, so build one */
-				itup_key = _bt_mkscankey(rel, targetkey);
+				itup_key = nbts_call(_bt_mkscankey, rel, targetkey);
 				/* find the leftmost leaf page with matching pivot/high key */
 				itup_key->pivotsearch = true;
-				stack = _bt_search(rel, itup_key, &sleafbuf, BT_READ, NULL);
+				stack = nbts_call(_bt_search, rel, itup_key, &sleafbuf, BT_READ, NULL);
 				/* won't need a second lock or pin on leafbuf */
 				_bt_relbuf(rel, sleafbuf);
 
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 9b730f303f..c9cd2b6026 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,10 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -177,33 +181,6 @@ btbuildempty(Relation index)
 	smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
diff --git a/src/backend/access/nbtree/nbtree_spec.h b/src/backend/access/nbtree/nbtree_spec.h
new file mode 100644
index 0000000000..4c342287f6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.h
@@ -0,0 +1,50 @@
+/*
+ * Specialized functions for nbtree.c
+ */
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+NBTS_FUNCTION(_bt_specialize)(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	nbts_call_norel(_bt_specialize, rel, rel);
+#else
+	rel->rd_indam->aminsert = NBTS_FUNCTION(btinsert);
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+NBTS_FUNCTION(btinsert)(Relation rel, Datum *values, bool *isnull,
+						ItemPointer ht_ctid, Relation heapRel,
+						IndexUniqueCheck checkUnique,
+						bool indexUnchanged,
+						IndexInfo *indexInfo)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	nbts_call_norel(_bt_specialize, rel, rel);
+
+	return nbts_call(btinsert, rel, values, isnull, ht_ctid, heapRel,
+					 checkUnique, indexUnchanged, indexInfo);
+#else
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = nbts_call(_bt_doinsert, rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+#endif
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index c74543bfde..e81eee9c35 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,11 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -46,6 +43,9 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -70,493 +70,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- */
-BTStack
-_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
-		   Snapshot snapshot)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split
- * is completed.  'stack' is only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  Snapshot snapshot)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		page = BufferGetPage(buf);
-		TestForOldSnapshot(snapshot, rel, page);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-			break;
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
-		{
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-			break;
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-			high = mid;
-	}
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-		{
-			high = mid;
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
 
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
@@ -625,217 +138,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-			return result;
-
-		scankey++;
-	}
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -1363,7 +665,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	 * Use the manufactured insertion scan key to descend the tree and
 	 * position ourselves on the target leaf page.
 	 */
-	stack = _bt_search(rel, &inskey, &buf, BT_READ, scan->xs_snapshot);
+	stack = nbts_call(_bt_search, rel, &inskey, &buf, BT_READ, scan->xs_snapshot);
 
 	/* don't need to keep the stack around... */
 	_bt_freestack(stack);
@@ -1392,7 +694,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
@@ -1422,9 +724,9 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	/*
 	 * Now load data from the first page of the scan.
 	 */
-	if (!_bt_readpage(scan, dir, offnum))
+	if (!nbts_call_norel(_bt_readpage, scan->indexRelation, scan, dir, offnum))
 	{
-		/*
+		/*`
 		 * There's no actually-matching data on this page.  Try to advance to
 		 * the next page.  Return false if there's no matching data at all.
 		 */
@@ -1498,280 +800,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2014,7 +1042,8 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 				PredicateLockPage(rel, blkno, scan->xs_snapshot);
 				/* see if there are any matches on this page */
 				/* note that this will clear moreRight if we can stop */
-				if (_bt_readpage(scan, dir, P_FIRSTDATAKEY(opaque)))
+				if (nbts_call_norel(_bt_readpage, scan->indexRelation,
+										scan, dir, P_FIRSTDATAKEY(opaque)))
 					break;
 			}
 			else if (scan->parallel_scan != NULL)
@@ -2116,7 +1145,8 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 				PredicateLockPage(rel, BufferGetBlockNumber(so->currPos.buf), scan->xs_snapshot);
 				/* see if there are any matches on this page */
 				/* note that this will clear moreLeft if we can stop */
-				if (_bt_readpage(scan, dir, PageGetMaxOffsetNumber(page)))
+				if (nbts_call_norel(_bt_readpage, scan->indexRelation, scan,
+										dir, PageGetMaxOffsetNumber(page)))
 					break;
 			}
 			else if (scan->parallel_scan != NULL)
@@ -2448,7 +1478,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	/*
 	 * Now load data from the first page of the scan.
 	 */
-	if (!_bt_readpage(scan, dir, start))
+	if (!nbts_call_norel(_bt_readpage, scan->indexRelation, scan, dir, start))
 	{
 		/*
 		 * There's no actually-matching data on this page.  Try to advance to
diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
new file mode 100644
index 0000000000..73d5370496
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -0,0 +1,994 @@
+/*
+ * Specialized functions for nbtsearch.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel, BTScanInsert key,
+											   Buffer buf);
+static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
+										OffsetNumber offnum);
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+NBTS_FUNCTION(_bt_binsrch)(Relation rel,
+						   BTScanInsert key,
+						   Buffer buf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = nbts_call(_bt_compare, rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+			high = mid;
+	}
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
+							OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (nbts_call(_bt_checkkeys, scan->indexRelation, scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			nbts_call(_bt_checkkeys, scan->indexRelation, scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = nbts_call(_bt_checkkeys, scan->indexRelation,
+									 scan, itup, indnatts, dir,
+									 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
+
+#endif /* NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ */
+BTStack
+NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
+						  int access, Snapshot snapshot)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = nbts_call(_bt_moveright, rel, key, *bufP,
+						  (access == BT_WRITE), stack_in,
+						  page_access, snapshot);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = nbts_call(_bt_binsrch, rel, key, *bufP);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = nbts_call(_bt_moveright, rel, key, *bufP, true, stack_in,
+						  BT_WRITE, snapshot);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split
+ * is completed.  'stack' is only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ */
+Buffer
+NBTS_FUNCTION(_bt_moveright)(Relation rel,
+							 BTScanInsert key,
+							 Buffer buf,
+							 bool forupdate,
+							 BTStack stack,
+							 int access,
+							 Snapshot snapshot)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		page = BufferGetPage(buf);
+		TestForOldSnapshot(snapshot, rel, page);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+			break;
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY) >= cmpval)
+		{
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+			break;
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = nbts_call(_bt_compare, rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+		{
+			high = mid;
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+NBTS_FUNCTION(_bt_compare)(Relation rel,
+						   BTScanInsert key,
+						   Page page,
+						   OffsetNumber offnum)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+	scankey = key->scankeys;
+	for (int i = 1; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+			return result;
+
+		scankey++;
+	}
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 9f60fa9894..f1d146ba71 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,9 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
 /*
  *	btbuild() -- build a new btree index.
@@ -566,7 +567,7 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 
 	wstate.heap = btspool->heap;
 	wstate.index = btspool->index;
-	wstate.inskey = _bt_mkscankey(wstate.index, NULL);
+	wstate.inskey = nbts_call(_bt_mkscankey, wstate.index, NULL);
 	/* _bt_mkscankey() won't set allequalimage without metapage */
 	wstate.inskey->allequalimage = _bt_allequalimage(wstate.index, true);
 	wstate.btws_use_wal = RelationNeedsWAL(wstate.index);
@@ -578,7 +579,7 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE,
 								 PROGRESS_BTREE_PHASE_LEAF_LOAD);
-	_bt_load(&wstate, btspool, btspool2);
+	nbts_call_norel(_bt_load, wstate.index, &wstate, btspool, btspool2);
 }
 
 /*
@@ -978,8 +979,8 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 			lastleft = (IndexTuple) PageGetItem(opage, ii);
 
 			Assert(IndexTupleSize(oitup) > last_truncextra);
-			truncated = _bt_truncate(wstate->index, lastleft, oitup,
-									 wstate->inskey);
+			truncated = nbts_call(_bt_truncate, wstate->index, lastleft, oitup,
+								  wstate->inskey);
 			if (!PageIndexTupleOverwrite(opage, P_HIKEY, (Item) truncated,
 										 IndexTupleSize(truncated)))
 				elog(ERROR, "failed to add high key to the index page");
@@ -1176,264 +1177,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			AssertState(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.h b/src/backend/access/nbtree/nbtsort_spec.h
new file mode 100644
index 0000000000..8f4a3602ca
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.h
@@ -0,0 +1,275 @@
+/*
+ * Specialized functions included in nbtsort.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static void NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
+									BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
+						BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			AssertState(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (nbts_call(_bt_keep_natts_fast, wstate->index, dstate->base,
+							   itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
+
+#endif
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index 241e26d338..8e5337cad7 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -692,7 +692,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	{
 		itemid = PageGetItemId(state->origpage, maxoff);
 		tup = (IndexTuple) PageGetItem(state->origpage, itemid);
-		keepnatts = _bt_keep_natts_fast(state->rel, tup, state->newitem);
+		keepnatts = nbts_call(_bt_keep_natts_fast, state->rel, tup, state->newitem);
 
 		if (keepnatts > 1 && keepnatts <= nkeyatts)
 		{
@@ -723,7 +723,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 		!_bt_adjacenthtid(&tup->t_tid, &state->newitem->t_tid))
 		return false;
 	/* Check same conditions as rightmost item case, too */
-	keepnatts = _bt_keep_natts_fast(state->rel, tup, state->newitem);
+	keepnatts = nbts_call(_bt_keep_natts_fast, state->rel, tup, state->newitem);
 
 	if (keepnatts > 1 && keepnatts <= nkeyatts)
 	{
@@ -972,7 +972,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 	 * avoid appending a heap TID in new high key, we're done.  Finish split
 	 * with default strategy and initial split interval.
 	 */
-	perfectpenalty = _bt_keep_natts_fast(state->rel, leftmost, rightmost);
+	perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, leftmost, rightmost);
 	if (perfectpenalty <= indnkeyatts)
 		return perfectpenalty;
 
@@ -993,7 +993,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 	 * If page is entirely full of duplicates, a single value strategy split
 	 * will be performed.
 	 */
-	perfectpenalty = _bt_keep_natts_fast(state->rel, leftmost, rightmost);
+	perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, leftmost, rightmost);
 	if (perfectpenalty <= indnkeyatts)
 	{
 		*strategy = SPLIT_MANY_DUPLICATES;
@@ -1031,8 +1031,8 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 
 		itemid = PageGetItemId(state->origpage, P_HIKEY);
 		hikey = (IndexTuple) PageGetItem(state->origpage, itemid);
-		perfectpenalty = _bt_keep_natts_fast(state->rel, hikey,
-											 state->newitem);
+		perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, hikey,
+								   state->newitem);
 		if (perfectpenalty <= indnkeyatts)
 			*strategy = SPLIT_SINGLE_VALUE;
 		else
@@ -1154,7 +1154,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 	lastleft = _bt_split_lastleft(state, split);
 	firstright = _bt_split_firstright(state, split);
 
-	return _bt_keep_natts_fast(state->rel, lastleft, firstright);
+	return nbts_call(_bt_keep_natts_fast, state->rel, lastleft, firstright);
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index ff260c393a..bc443ebd27 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,11 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1221,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1704,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
new file mode 100644
index 0000000000..a4b934ae7a
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.h
@@ -0,0 +1,772 @@
+/*
+ * Specialized functions included in nbtutils.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static bool NBTS_FUNCTION(_bt_check_rowcompare)(ScanKey skey,
+												IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+												ScanDirection dir, bool *continuescan);
+
+static int	NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
+										  IndexTuple firstright, BTScanInsert itup_key);
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+NBTS_FUNCTION(_bt_check_rowcompare)(ScanKey skey, IndexTuple tuple,
+									int tupnatts, TupleDesc tupdesc,
+									ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
+							  IndexTuple firstright, BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == nbts_call(_bt_keep_natts_fast, rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+#endif /* NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+NBTS_FUNCTION(_bt_checkkeys)(Relation rel, IndexScanDesc scan,
+							 IndexTuple tuple, int tupnatts,
+							 ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (nbts_call_norel(_bt_check_rowcompare, rel, key, tuple,
+								tupnatts, tupdesc, dir, continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+NBTS_FUNCTION(_bt_truncate)(Relation rel, IndexTuple lastleft,
+							IndexTuple firstright, BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = nbts_call(_bt_keep_natts, rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel,
+								   IndexTuple lastleft,
+								   IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 31554fd867..27a5d53324 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -1153,7 +1153,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 
 	state->tupDesc = tupDesc;	/* assume we need not copy tupDesc */
 
-	indexScanKey = _bt_mkscankey(indexRel, NULL);
+	indexScanKey = nbts_call(_bt_mkscankey, indexRel, NULL);
 
 	if (state->indexInfo->ii_Expressions != NULL)
 	{
@@ -1251,7 +1251,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	state->enforceUnique = enforceUnique;
 	state->uniqueNullsNotDistinct = uniqueNullsNotDistinct;
 
-	indexScanKey = _bt_mkscankey(indexRel, NULL);
+	indexScanKey = nbts_call(_bt_mkscankey, indexRel, NULL);
 
 	/* Prepare SortSupport data for each column */
 	state->sortKeys = (SortSupport) palloc0(state->nKeys *
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 93f8267b48..83e0dbab16 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1116,15 +1116,47 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+
+
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define NBTS_ENABLED
+
+#ifdef NBTS_ENABLED
+
+/*
+ * Access a specialized nbtree function, based on the shape of the index key.
+ */
+
+#define NBT_SPECIALIZE_CALL(function, rel, ...) \
+( \
+	NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+)
+
+#else /* not defined NBTS_ENABLED */
+
+#define NBT_SPECIALIZE_CALL(function, rel, ...) function(__VA_ARGS__)
+
+#endif /* NBTS_ENABLED */
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specialized.h"
+#include "nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1155,9 +1187,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
-						   IndexTuple newitem, Size newitemsz,
-						   bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1173,9 +1202,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Buffer lbuf, BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, BTStack stack, BlockNumber child);
 
@@ -1223,12 +1249,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
-						  int access, Snapshot snapshot);
-extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
@@ -1237,7 +1257,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1245,8 +1264,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1259,10 +1276,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
new file mode 100644
index 0000000000..23fdda4f0e
--- /dev/null
+++ b/src/include/access/nbtree_specialize.h
@@ -0,0 +1,204 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_call(function, indexrel, ...rest_of_args), and
+ *   nbts_call_norel(function, indexrel, ...args)
+ *     This will call the specialized variant of 'function' based on the index
+ *     relation data.
+ *     The difference between nbts_call and nbts_call_norel is that _call
+ *     uses indexrel as first argument in the function call, whereas
+ *     nbts_call_norel does not.
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ *
+ * example usage:
+ *
+ * kwithnulls = nbts_call_norel(_bt_key_hasnulls, myindex, mytuple, tupDesc);
+ *
+ * NBTS_FUNCTION(_bt_key_hasnulls)(IndexTuple mytuple, TupleDesc tupDesc)
+ * {
+ *    nbts_attiterdeclare(mytuple);
+ *    nbts_attiterinit(mytuple, 1, tupDesc);
+ *    nbts_foreachattr(1, 10)
+ *    {
+ *        Datum it = nbts_attiter_nextattdatum(tuple, tupDesc);
+ *        if (nbts_attiter_curattisnull(tuple))
+ *           return true;
+ *    }
+ *    return false
+ * }
+ */
+
+/*
+ * Call a potentially specialized function for a given btree operation.
+ *
+ * NB: the rel argument is evaluated multiple times.
+ */
+#define nbts_call(name, rel, ...) \
+	nbts_call_norel(name, (rel), (rel), __VA_ARGS__)
+
+#ifdef NBTS_ENABLED
+
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+#ifdef nbts_call_norel
+#undef nbts_call_norel
+#endif
+
+#define nbts_call_norel(name, rel, ...) \
+	(NBTS_FUNCTION(name)(__VA_ARGS__))
+
+/*
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_CACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/* reset call to SPECIALIZE_CALL for default behaviour */
+#undef nbts_call_norel
+#define nbts_call_norel(name, rel, ...) \
+	NBT_SPECIALIZE_CALL(name, (rel), __VA_ARGS__)
+
+/*
+ * "Default", externally accessible, not so much optimized functions
+ */
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+/* for the default functions, we want to use the unspecialized name. */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) name
+
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/* from here on there are no more NBTS_FUNCTIONs */
+#undef NBTS_FUNCTION
+
+#else /* not defined NBTS_ENABLED */
+
+/*
+ * NBTS_ENABLE is not defined, so we don't want to use the specializations.
+ * We revert to the behaviour from PG14 and earlier, which only uses
+ * attcacheoff.
+ */
+
+#define NBTS_FUNCTION(name) name
+
+#define nbts_call_norel(name, rel, ...) \
+	name(__VA_ARGS__)
+
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+
+#endif /* !NBTS_ENABLED */
diff --git a/src/include/access/nbtree_specialized.h b/src/include/access/nbtree_specialized.h
new file mode 100644
index 0000000000..c45fa84aed
--- /dev/null
+++ b/src/include/access/nbtree_specialized.h
@@ -0,0 +1,67 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void
+NBTS_FUNCTION(_bt_specialize)(Relation rel);
+
+extern bool
+NBTS_FUNCTION(btinsert)(Relation rel, Datum *values, bool *isnull,
+						ItemPointer ht_ctid, Relation heapRel,
+						IndexUniqueCheck checkUnique,
+						bool indexUnchanged,
+						struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void
+NBTS_FUNCTION(_bt_dedup_pass)(Relation rel, Buffer buf, Relation heapRel,
+							  IndexTuple newitem, Size newitemsz,
+							  bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool
+NBTS_FUNCTION(_bt_doinsert)(Relation rel, IndexTuple itup,
+							IndexUniqueCheck checkUnique, bool indexUnchanged,
+							Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack
+NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key,
+						  Buffer *bufP, int access,
+						  Snapshot snapshot);
+extern Buffer
+NBTS_FUNCTION(_bt_moveright)(Relation rel, BTScanInsert key, Buffer buf,
+							 bool forupdate, BTStack stack, int access,
+							 Snapshot snapshot);
+extern OffsetNumber
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate);
+extern int32
+NBTS_FUNCTION(_bt_compare)(Relation rel, BTScanInsert key,
+						   Page page, OffsetNumber offnum);
+
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert
+NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup);
+extern bool
+NBTS_FUNCTION(_bt_checkkeys)(Relation rel, IndexScanDesc scan,
+							 IndexTuple tuple, int tupnatts,
+							 ScanDirection dir, bool *continuescan);
+extern IndexTuple
+NBTS_FUNCTION(_bt_truncate)(Relation rel, IndexTuple lastleft,
+							IndexTuple firstright, BTScanInsert itup_key);
+extern int
+NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel, IndexTuple lastleft,
+								   IndexTuple firstright);
-- 
2.30.2

From ef93c39b89e9db22b85b2893caf8fb97dc2651c2 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 7 Apr 2022 12:30:00 +0200
Subject: [PATCH v4 2/8] Use specialized attribute iterators in
 backend/*/nbt*_spec.h

Split out for making it clear what substantial changes were made to the
pre-existing functions.

Even though not all nbt*_spec functions have been updated; most call sites
now can directly call the specialized functions instead of having to determine
the right specialization based on the (potentially locally unavailable) index
relation, making the specialization of those functions worth the effort.
---
 src/backend/access/nbtree/nbtsearch_spec.h | 16 +++---
 src/backend/access/nbtree/nbtsort_spec.h   | 24 +++++----
 src/backend/access/nbtree/nbtutils_spec.h  | 63 +++++++++++++---------
 3 files changed, 62 insertions(+), 41 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
index 73d5370496..a5c5f2b94f 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.h
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -823,6 +823,7 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -854,23 +855,26 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
diff --git a/src/backend/access/nbtree/nbtsort_spec.h b/src/backend/access/nbtree/nbtsort_spec.h
index 8f4a3602ca..d3f2db2dc4 100644
--- a/src/backend/access/nbtree/nbtsort_spec.h
+++ b/src/backend/access/nbtree/nbtsort_spec.h
@@ -27,8 +27,7 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -50,7 +49,7 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -82,22 +81,25 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 			}
 			else if (itup != NULL)
 			{
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 				int32		compare = 0;
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
index a4b934ae7a..638eff18f6 100644
--- a/src/backend/access/nbtree/nbtutils_spec.h
+++ b/src/backend/access/nbtree/nbtutils_spec.h
@@ -211,6 +211,8 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -222,20 +224,22 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -243,6 +247,7 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -295,7 +300,7 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -326,7 +331,10 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -337,27 +345,30 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -744,24 +755,28 @@ NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft,itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) !=
+			nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
-- 
2.30.2

From 6b8384a22b1659bea4003c478b454960115ec025 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:54:52 +0200
Subject: [PATCH v4 3/8] Specialize the nbtree rd_indam entry.

Because each rd_indam struct is seperately allocated for each index, we can
freely modify it at runtime without impacting other indexes of the same
access method. For btinsert (which effectively only calls _bt_insert) it is
useful to specialize that function, which also makes rd_indam->aminsert a
good signal whether or not the indexRelation has been fully optimized yet.
---
 src/backend/access/nbtree/nbtree.c    |  7 +++++++
 src/backend/access/nbtree/nbtsearch.c |  2 ++
 src/backend/access/nbtree/nbtsort.c   |  2 ++
 src/include/access/nbtree.h           | 14 ++++++++++++++
 4 files changed, 25 insertions(+)

diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index c9cd2b6026..5f4271f718 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -160,6 +160,8 @@ btbuildempty(Relation index)
 	metapage = (Page) palloc(BLCKSZ);
 	_bt_initmetapage(metapage, P_NONE, 0, _bt_allequalimage(index, false));
 
+	nbt_opt_specialize(index);
+
 	/*
 	 * Write the page and log it.  It might seem that an immediate sync would
 	 * be sufficient to guarantee that the file exists on disk, but recovery
@@ -322,6 +324,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -764,6 +768,7 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 {
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
+	nbt_opt_specialize(info->index);
 
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
@@ -797,6 +802,8 @@ btvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
 	if (info->analyze_only)
 		return stats;
 
+	nbt_opt_specialize(info->index);
+
 	/*
 	 * If btbulkdelete was called, we need not do anything (we just maintain
 	 * the information used within _bt_vacuum_needs_cleanup() by calling
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index e81eee9c35..d5152bfcb7 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -181,6 +181,8 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
+	nbt_opt_specialize(scan->indexRelation);
+
 	pgstat_count_index_scan(rel);
 
 	/*
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index f1d146ba71..22c7163197 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -305,6 +305,8 @@ btbuild(Relation heap, Relation index, IndexInfo *indexInfo)
 	BTBuildState buildstate;
 	double		reltuples;
 
+	nbt_opt_specialize(index);
+
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
 		ResetUsage();
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 83e0dbab16..489b623663 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1132,6 +1132,19 @@ typedef struct BTOptions
 
 #ifdef NBTS_ENABLED
 
+/*
+ * Replace the functions in the rd_indam struct with a variant optimized for
+ * our key shape, if not already done.
+ *
+ * It only needs to be done once for every index relation loaded, so it's
+ * quite unlikely we need to do this and thus marked unlikely().
+ */
+#define nbt_opt_specialize(rel) \
+do { \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert)) \
+		_bt_specialize(rel); \
+} while (false)
+
 /*
  * Access a specialized nbtree function, based on the shape of the index key.
  */
@@ -1143,6 +1156,7 @@ typedef struct BTOptions
 
 #else /* not defined NBTS_ENABLED */
 
+#define nbt_opt_specialize(rel)
 #define NBT_SPECIALIZE_CALL(function, rel, ...) function(__VA_ARGS__)
 
 #endif /* NBTS_ENABLED */
-- 
2.30.2

From 1cceed69b9746c15155bbaa81a84c90f90ccca3f Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 7 Apr 2022 12:47:50 +0200
Subject: [PATCH v4 4/8] Optimize attribute iterator access for single-column
 btree keys

This removes the index_getattr_nocache call path, which has significant overhead.
---
 src/include/access/nbtree.h            |  9 +++-
 src/include/access/nbtree_specialize.h | 63 ++++++++++++++++++++++++++
 2 files changed, 71 insertions(+), 1 deletion(-)

diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 489b623663..1559399b0e 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1120,6 +1120,7 @@ typedef struct BTOptions
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_COLUMN single
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 
@@ -1151,7 +1152,13 @@ do { \
 
 #define NBT_SPECIALIZE_CALL(function, rel, ...) \
 ( \
-	NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? (   \
+		NBTS_MAKE_NAME(function, NBTS_TYPE_SINGLE_COLUMN)(__VA_ARGS__) \
+	) \
+	: \
+	( \
+		NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+	) \
 )
 
 #else /* not defined NBTS_ENABLED */
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
index 23fdda4f0e..9733a27bdd 100644
--- a/src/include/access/nbtree_specialize.h
+++ b/src/include/access/nbtree_specialize.h
@@ -79,6 +79,69 @@
 #define nbts_call_norel(name, rel, ...) \
 	(NBTS_FUNCTION(name)(__VA_ARGS__))
 
+/*
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path may never be used for indexes with multiple key
+ *  columns, because it does not ever continue to a next column.
+ */
+
+#define NBTS_SPECIALIZING_SINGLE_COLUMN
+#define NBTS_TYPE NBTS_TYPE_SINGLE_COLUMN
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+/*
+ * We void endAttNum to prevent unused variable warnings.
+ * The if- and for-loop are structured like this to make the compiler
+ * unroll the loop and detect only one single iteration. We need `break`
+ * in the following code block, so just a plain 'if' statement would
+ * not work.
+ */
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+/*
+ * Simplified (optimized) variant of index_getattr specialized for extracting
+ * only the first attribute: cache offset is guaranteed to be 0, and as such
+ * no cache is required.
+ */
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	(IndexTupleHasNulls(itup) && att_isnull(0, (char *)(itup) + sizeof(IndexTupleData))) ? \
+	( \
+		(NBTS_MAKE_NAME(itup, isNull)) = true, \
+		(Datum)NULL \
+	) \
+	: \
+	( \
+		(NBTS_MAKE_NAME(itup, isNull) = false), \
+		(Datum) fetchatt(TupleDescAttr((tupDesc), 0), \
+		(char *) (itup) + IndexInfoFindDataOffset((itup)->t_info)) \
+	) \
+)
+
+#define nbts_attiter_curattisnull(tuple) \
+	NBTS_MAKE_NAME(tuple, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_COLUMN
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
  */
-- 
2.30.2

From a3ff1bc255ec747e0e469233612e0505b4cc1a76 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:51:01 +0200
Subject: [PATCH v4 5/8] Add a function whose task it is to populate all
 attcacheoff-s of a TupleDesc's attributes

It fills uncacheable offsets with -2; as opposed to -1 which signals
"unknown", thus allowing users of the API to determine the cache-ability
of an attribute at O(1) complexity after this one-time O(n) cost, as
opposed to the repeated O(n) cost that currently applies.
---
 src/backend/access/common/tupdesc.c | 97 +++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |  2 +
 2 files changed, 99 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 9f41b1e854..5630fc9da0 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -910,3 +910,100 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid value.
+ *
+ * Sets attcacheoff to -2 for uncacheable attributes (i.e. attributes after a
+ * variable length attributes).
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	i, j;
+
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+	{
+		/*
+		 * Already done the calculations, find the last attribute that has
+		 * cache offset.
+		 */
+		for (i = (AttrNumber) numberOfAttributes; i > 1; i--)
+		{
+			if (TupleDescAttr(desc, i - 1)->attcacheoff != -2)
+				return i;
+		}
+
+		return 1;
+	}
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	i = 1;
+	/*
+	 * Someone might have set some offsets previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (i < numberOfAttributes && TupleDescAttr(desc, i)->attcacheoff > 0)
+		i++;
+
+	/* Cache offset is undetermined. Start calculating offsets if possible */
+	if (i < numberOfAttributes &&
+		TupleDescAttr(desc, i)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, i - 1);
+		Size off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (i < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, i);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+						att->attcacheoff = off;
+					else
+						att->attcacheoff = -2;
+					i++;
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				i++;
+			}
+		} else {
+			if (off == att_align_nominal(off, att->attalign))
+				att->attcacheoff = off;
+			else
+				att->attcacheoff = -2;
+			i++;
+		}
+	}
+
+	/*
+	 * No cacheable offsets left. Fill the rest with -2s, but return the latest
+	 * cached offset.
+	 */
+	j = i;
+
+	while (i < numberOfAttributes)
+	{
+		TupleDescAttr(desc, i)->attcacheoff = -2;
+		i++;
+	}
+
+	return j;
+}
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index 28dd6de18b..219f837875 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.30.2

From f8ea88c8da8fa1bd43e678589992455116cd82ef Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:44:01 +0200
Subject: [PATCH v4 6/8] Implement specialized uncacheable attribute iteration

Uses an iterator to prevent doing duplicate work while iterating over
attributes.

Inspiration: https://www.postgresql.org/message-id/CAEze2WjE9ka8i%3Ds-Vv5oShro9xTrt5VQnQvFG9AaRwWpMm3-fg%40mail.gmail.com
---
 src/backend/access/nbtree/nbtree_spec.h |   1 +
 src/include/access/itup_attiter.h       | 198 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  13 +-
 src/include/access/nbtree_specialize.h  |  34 ++++
 4 files changed, 244 insertions(+), 2 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/backend/access/nbtree/nbtree_spec.h b/src/backend/access/nbtree/nbtree_spec.h
index 4c342287f6..88b01c86f7 100644
--- a/src/backend/access/nbtree/nbtree_spec.h
+++ b/src/backend/access/nbtree/nbtree_spec.h
@@ -9,6 +9,7 @@ void
 NBTS_FUNCTION(_bt_specialize)(Relation rel)
 {
 #ifdef NBTS_SPECIALIZING_DEFAULT
+	PopulateTupleDescCacheOffsets(rel->rd_att);
 	nbts_call_norel(_bt_specialize, rel, rel);
 #else
 	rel->rd_indam->aminsert = NBTS_FUNCTION(btinsert);
diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..9f16a4b3d7
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,198 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 1559399b0e..92894e4ea7 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1122,6 +1123,7 @@ typedef struct BTOptions
  */
 #define NBTS_TYPE_SINGLE_COLUMN single
 #define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_DEFAULT default
 
 
@@ -1152,12 +1154,19 @@ do { \
 
 #define NBT_SPECIALIZE_CALL(function, rel, ...) \
 ( \
-	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? (   \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? ( \
 		NBTS_MAKE_NAME(function, NBTS_TYPE_SINGLE_COLUMN)(__VA_ARGS__) \
 	) \
 	: \
 	( \
-		NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+		TupleDescAttr(RelationGetDescr(rel), \
+					  IndexRelationGetNumberOfKeyAttributes(rel) - 1)->attcacheoff > 0 ? ( \
+			NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+		) \
+		: \
+		( \
+			NBTS_MAKE_NAME(function, NBTS_TYPE_UNCACHED)(__VA_ARGS__) \
+		) \
 	) \
 )
 
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
index 9733a27bdd..aa8cc51666 100644
--- a/src/include/access/nbtree_specialize.h
+++ b/src/include/access/nbtree_specialize.h
@@ -175,6 +175,40 @@
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /* reset call to SPECIALIZE_CALL for default behaviour */
 #undef nbts_call_norel
 #define nbts_call_norel(name, rel, ...) \
-- 
2.30.2

From d9e1abfafbdb1c0c9e80bb4cdba9a1a43e33b699 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 21 Apr 2022 16:22:07 +0200
Subject: [PATCH v4 7/8] Add specialization to btree index creation.

This was an oversight that is corrected easily; but an oversight nonetheless.
This increases the (re)build performance of indexes by another few percents.
---
 src/backend/utils/sort/tuplesort.c      | 147 ++---------------------
 src/backend/utils/sort/tuplesort_nbts.h | 148 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  18 +++
 3 files changed, 175 insertions(+), 138 deletions(-)
 create mode 100644 src/backend/utils/sort/tuplesort_nbts.h

diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 27a5d53324..44d7d831ff 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -655,8 +655,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int len);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static void copytup_index(Tuplesortstate *state, SortTuple *stup, void *tup);
@@ -679,6 +677,10 @@ static void free_sort_tuple(Tuplesortstate *state, SortTuple *stup);
 static void tuplesort_free(Tuplesortstate *state);
 static void tuplesort_updatemax(Tuplesortstate *state);
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesort_nbts.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
 /*
  * Specialized comparators that we can inline into specialized sorts.  The goal
  * is to try to sort two tuples without having to follow the pointers to the
@@ -1239,7 +1241,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 								sortopt & TUPLESORT_RANDOMACCESS,
 								PARALLEL_SORT(state));
 
-	state->comparetup = comparetup_index_btree;
+	state->comparetup = NBT_SPECIALIZE_NAME(comparetup_index_btree, indexRel);
 	state->copytup = copytup_index;
 	state->writetup = writetup_index;
 	state->readtup = readtup_index;
@@ -1357,7 +1359,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 
 	state->nKeys = IndexRelationGetNumberOfKeyAttributes(indexRel);
 
-	state->comparetup = comparetup_index_btree;
+	state->comparetup = NBT_SPECIALIZE_NAME(comparetup_index_btree, indexRel);
 	state->copytup = copytup_index;
 	state->writetup = writetup_index;
 	state->readtup = readtup_index;
@@ -4320,142 +4322,11 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
  * The btree and hash cases require separate comparison functions, but the
  * IndexTuple representation is the same so the copy/write/read support
  * functions can be shared.
+ *
+ * nbtree function can be found in tuplesort_nbts.h, and is included
+ * through the nbtree specialization functions.
  */
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	SortSupport sortKey = state->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = state->nKeys;
-	tupDes = RelationGetDescr(state->indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (state->enforceUnique && !(!state->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(state->indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(state->indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(state->heapRel,
-									RelationGetRelationName(state->indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesort_nbts.h b/src/backend/utils/sort/tuplesort_nbts.h
new file mode 100644
index 0000000000..d1b2670747
--- /dev/null
+++ b/src/backend/utils/sort/tuplesort_nbts.h
@@ -0,0 +1,148 @@
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static int NBTS_FUNCTION(comparetup_index_btree)(const SortTuple *a,
+												 const SortTuple *b,
+												 Tuplesortstate *state);
+
+static int
+NBTS_FUNCTION(comparetup_index_btree)(const SortTuple *a, const SortTuple *b,
+									  Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	SortSupport sortKey = state->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = state->nKeys;
+	tupDes = RelationGetDescr(state->indexRel);
+
+	if (!sortKey->abbrev_converter)
+	{
+		nkey = 2;
+		sortKey++;
+	}
+	else
+		nkey = 1;
+
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
+	{
+		Datum		datum1,
+					datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+		{
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		}
+		else
+		{
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
+		}
+
+		if (compare != 0)
+			return compare;
+
+		if (nbts_attiter_curattisnull(tuple1))
+			equal_hasnull = true;
+
+		sortKey++;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (state->enforceUnique && !(!state->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(state->indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(state->indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(state->heapRel,
+									   RelationGetRelationName(state->indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
+
+#endif
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 92894e4ea7..11116b47ca 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1170,6 +1170,24 @@ do { \
 	) \
 )
 
+#define NBT_SPECIALIZE_NAME(name, rel) \
+( \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_COLUMN) \
+	) \
+	: \
+	( \
+		TupleDescAttr(RelationGetDescr(rel), \
+					  IndexRelationGetNumberOfKeyAttributes(rel) - 1)->attcacheoff > 0 ? ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+		) \
+		: \
+		( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED) \
+		) \
+	) \
+)
+
 #else /* not defined NBTS_ENABLED */
 
 #define nbt_opt_specialize(rel)
-- 
2.30.2

From 36019f49e51a82f5a6b33f02486dd59f0c06e509 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Mon, 6 Jun 2022 23:16:18 +0200
Subject: [PATCH v4 8/8] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also have those prefixing attributes that equal the
scankey.

We cannot propagate this information to _binsrch on lower pages,
as this downstream page may concurrently have split and/or have
merged with its deleted left neighbour (see [0]), which moves
the keyspace of the linked page. We thus can only trust the
current state of this current page for this optimization, which
means we must validate this state each time we open the page.

Although this limits the overall applicability of the
performance improvement, it still allows for a nice performance
improvement in most cases where initial columns have many
duplicate values and a compare function that is not cheap.

Additionally, most of the time a pages' highkey is equal to the
right seperator on the parent page. By storing this seperator
and doing a binary equality check, we can cheaply validate the
highkey on a page, which also allows us to carry over the
right seperators' prefix into the page.
---
 contrib/amcheck/verify_nbtree.c            |  17 +--
 src/backend/access/nbtree/README           |  25 +++++
 src/backend/access/nbtree/nbtinsert.c      |  14 ++-
 src/backend/access/nbtree/nbtinsert_spec.h |  22 ++--
 src/backend/access/nbtree/nbtsearch.c      |   3 +-
 src/backend/access/nbtree/nbtsearch_spec.h | 115 ++++++++++++++++++---
 src/include/access/nbtree_specialized.h    |   9 +-
 7 files changed, 169 insertions(+), 36 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 2beeebb163..8c4215372a 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2700,6 +2700,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2709,13 +2710,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2777,6 +2778,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2787,7 +2789,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2839,10 +2841,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2862,10 +2865,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2900,13 +2904,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 3c08888c23..13ac9ee2be 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,31 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+potentially saving cycles.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by an inner page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. (2,2) to (1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+The positive part of this, is that we already have results of the highest
+value of a page: a pages' highkey is compared to the scankey while we have
+a pin on the page in the _bt_moveright procedure. The _bt_binsrch procedure
+will use this result as a rightmost prefix compare, and for each step in the
+binary search (that does not compare less than the insert key) improve the
+equal-prefix bounds.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index ec6c73d1cc..20e5f33f98 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -132,7 +132,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = nbts_call(_bt_binsrch_insert, rel, insertstate);
+	offset = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -142,6 +142,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -177,7 +179,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset) < 0);
+				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset,
+								 &cmpcol) < 0);
 				break;
 			}
 
@@ -202,7 +205,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (nbts_call(_bt_compare, rel, itup_key, page, offset) != 0)
+					if (nbts_call(_bt_compare, rel, itup_key, page, offset,
+								  &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -412,11 +416,13 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY);
+			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY,
+								   &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
diff --git a/src/backend/access/nbtree/nbtinsert_spec.h b/src/backend/access/nbtree/nbtinsert_spec.h
index 97c866aea3..ccba0fa5ed 100644
--- a/src/backend/access/nbtree/nbtinsert_spec.h
+++ b/src/backend/access/nbtree/nbtinsert_spec.h
@@ -73,6 +73,7 @@ NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	comparecol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -91,7 +92,8 @@ NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				nbts_call(_bt_compare, rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				nbts_call(_bt_compare, rel, insertstate->itup_key, page,
+						  P_HIKEY, &comparecol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -221,6 +223,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -238,7 +241,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0)
+					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, insertstate, stack);
@@ -291,6 +294,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -321,7 +325,8 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) != 0 ||
+				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY,
+						  &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -336,10 +341,13 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) || nbts_call(_bt_compare, rel, itup_key,
+												page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -358,7 +366,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index d5152bfcb7..607940bbcd 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -178,6 +178,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	AttrNumber	attno = 1;
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -696,7 +697,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf);
+	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf, &attno);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
index a5c5f2b94f..19a6178334 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.h
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -10,8 +10,10 @@
  */
 #ifndef NBTS_SPECIALIZING_DEFAULT
 
-static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel, BTScanInsert key,
-											   Buffer buf);
+static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel,
+											   BTScanInsert key,
+											   Buffer buf,
+											   AttrNumber *highkeycmpcol);
 static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
 										OffsetNumber offnum);
 
@@ -38,7 +40,8 @@ static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
 static OffsetNumber
 NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 						   BTScanInsert key,
-						   Buffer buf)
+						   Buffer buf,
+						   AttrNumber *highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -46,6 +49,8 @@ NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -87,17 +92,26 @@ NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = nbts_call(_bt_compare, rel, key, page, mid);
+		result = nbts_call(_bt_compare, rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
 
+	*highkeycmpcol = highcmpcol;
+
 	/*
 	 * At this point we have high == low, but be careful: they could point
 	 * past the last slot on the page.
@@ -423,6 +437,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
 
 	/* Get the root page to start with */
 	*bufP = _bt_getroot(rel, access);
@@ -441,6 +456,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		IndexTuple	itup;
 		BlockNumber child;
 		BTStack		new_stack;
+		AttrNumber	highkeycmpcol = 1;
 
 		/*
 		 * Race -- the page we just grabbed may have split since we read its
@@ -456,7 +472,8 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 */
 		*bufP = nbts_call(_bt_moveright, rel, key, *bufP,
 						  (access == BT_WRITE), stack_in,
-						  page_access, snapshot);
+						  page_access, snapshot, &highkeycmpcol,
+						  (char *) tupdatabuf);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -468,12 +485,17 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = nbts_call(_bt_binsrch, rel, key, *bufP);
+		offnum = nbts_call(_bt_binsrch, rel, key, *bufP, &highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		if (highkeycmpcol > 1)
+		{
+			memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+		}
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -507,6 +529,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		AttrNumber highkeycmpcol = 1;
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -517,7 +540,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = nbts_call(_bt_moveright, rel, key, *bufP, true, stack_in,
-						  BT_WRITE, snapshot);
+						  BT_WRITE, snapshot, &highkeycmpcol, (char *) tupdatabuf);
 	}
 
 	return stack_in;
@@ -565,12 +588,16 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 							 bool forupdate,
 							 BTStack stack,
 							 int access,
-							 Snapshot snapshot)
+							 Snapshot snapshot,
+							 AttrNumber *comparecol,
+							 char *tupdatabuf)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
+	Assert(PointerIsValid(comparecol));
+
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
 	 * this page is > the high key stored on the page, then the page has split
@@ -592,12 +619,17 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -623,14 +655,49 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY) >= cmpval)
+		/*
+		 * When comparecol is > 1, tupdatabuf is filled with the right seperator
+		 * of the parent node. This allows us to do a binary equality check
+		 * between the parent node's right seperator (which is < key) and this
+		 * page's P_HIKEY. If they equal, we can reuse the result of the
+		 * parent node's rightkey compare, which means we can potentially save
+		 * a full key compare.
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, with this optimization we can
+		 * skip one of those.
+		 * 
+		 * 3: 1 for the highkey (rightmost), and on average 2 before we move
+		 * right in the binary search on the page.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			}
+		}
+
+		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY,
+										  &cmpcol) >= cmpval)
 		{
 			/* step right one page */
+			*comparecol = 1;
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -663,7 +730,8 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
  * list split).
  */
 OffsetNumber
-NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate,
+								  AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -673,6 +741,7 @@ NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -723,16 +792,21 @@ NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = nbts_call(_bt_compare, rel, key, page, mid);
+		result = nbts_call(_bt_compare, rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -813,7 +887,8 @@ int32
 NBTS_FUNCTION(_bt_compare)(Relation rel,
 						   BTScanInsert key,
 						   Page page,
-						   OffsetNumber offnum)
+						   OffsetNumber offnum,
+						   AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -854,10 +929,11 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	nbts_attiterinit(itup, 1, itupdesc);
 
-	nbts_foreachattr(1, ncmpkey)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+	scankey = key->scankeys + ((*comparecol) - 1);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
 
@@ -902,11 +978,20 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = nbts_attiter_attnum;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
diff --git a/src/include/access/nbtree_specialized.h b/src/include/access/nbtree_specialized.h
index c45fa84aed..ddceb4a4aa 100644
--- a/src/include/access/nbtree_specialized.h
+++ b/src/include/access/nbtree_specialized.h
@@ -43,12 +43,15 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key,
 extern Buffer
 NBTS_FUNCTION(_bt_moveright)(Relation rel, BTScanInsert key, Buffer buf,
 							 bool forupdate, BTStack stack, int access,
-							 Snapshot snapshot);
+							 Snapshot snapshot, AttrNumber *comparecol,
+							 char *tupdatabuf);
 extern OffsetNumber
-NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate);
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate,
+								  AttrNumber highcmpcol);
 extern int32
 NBTS_FUNCTION(_bt_compare)(Relation rel, BTScanInsert key,
-						   Page page, OffsetNumber offnum);
+						   Page page, OffsetNumber offnum,
+						   AttrNumber *comparecol);
 
 /*
  * prototypes for functions in nbtutils_spec.h
-- 
2.30.2

From 7f13603d7a37dae59ca5d08346d79e67e5d3fe4e Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 7 Apr 2022 12:30:00 +0200
Subject: [PATCH v5 2/8] Use specialized attribute iterators in
 backend/*/nbt*_spec.h

Split out for making it clear what substantial changes were made to the
pre-existing functions.

Even though not all nbt*_spec functions have been updated; most call sites
now can directly call the specialized functions instead of having to determine
the right specialization based on the (potentially locally unavailable) index
relation, making the specialization of those functions worth the effort.
---
 src/backend/access/nbtree/nbtsearch_spec.h | 16 +++---
 src/backend/access/nbtree/nbtsort_spec.h   | 24 +++++----
 src/backend/access/nbtree/nbtutils_spec.h  | 63 +++++++++++++---------
 3 files changed, 62 insertions(+), 41 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
index 73d5370496..a5c5f2b94f 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.h
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -823,6 +823,7 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -854,23 +855,26 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
diff --git a/src/backend/access/nbtree/nbtsort_spec.h b/src/backend/access/nbtree/nbtsort_spec.h
index 8f4a3602ca..d3f2db2dc4 100644
--- a/src/backend/access/nbtree/nbtsort_spec.h
+++ b/src/backend/access/nbtree/nbtsort_spec.h
@@ -27,8 +27,7 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -50,7 +49,7 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -82,22 +81,25 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 			}
 			else if (itup != NULL)
 			{
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 				int32		compare = 0;
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
index a4b934ae7a..638eff18f6 100644
--- a/src/backend/access/nbtree/nbtutils_spec.h
+++ b/src/backend/access/nbtree/nbtutils_spec.h
@@ -211,6 +211,8 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -222,20 +224,22 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -243,6 +247,7 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -295,7 +300,7 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -326,7 +331,10 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -337,27 +345,30 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -744,24 +755,28 @@ NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft,itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) !=
+			nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
-- 
2.30.2

From d33e725c6e0dfd45a2b6e1461fcbdb744249f9ae Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 7 Apr 2022 12:47:50 +0200
Subject: [PATCH v5 4/8] Optimize attribute iterator access for single-column
 btree keys

This removes the index_getattr_nocache call path, which has significant overhead.
---
 src/include/access/nbtree.h            |  9 +++-
 src/include/access/nbtree_specialize.h | 63 ++++++++++++++++++++++++++
 2 files changed, 71 insertions(+), 1 deletion(-)

diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 489b623663..1559399b0e 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1120,6 +1120,7 @@ typedef struct BTOptions
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_COLUMN single
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 
@@ -1151,7 +1152,13 @@ do { \
 
 #define NBT_SPECIALIZE_CALL(function, rel, ...) \
 ( \
-	NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? (   \
+		NBTS_MAKE_NAME(function, NBTS_TYPE_SINGLE_COLUMN)(__VA_ARGS__) \
+	) \
+	: \
+	( \
+		NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+	) \
 )
 
 #else /* not defined NBTS_ENABLED */
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
index 23fdda4f0e..9733a27bdd 100644
--- a/src/include/access/nbtree_specialize.h
+++ b/src/include/access/nbtree_specialize.h
@@ -79,6 +79,69 @@
 #define nbts_call_norel(name, rel, ...) \
 	(NBTS_FUNCTION(name)(__VA_ARGS__))
 
+/*
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path may never be used for indexes with multiple key
+ *  columns, because it does not ever continue to a next column.
+ */
+
+#define NBTS_SPECIALIZING_SINGLE_COLUMN
+#define NBTS_TYPE NBTS_TYPE_SINGLE_COLUMN
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+/*
+ * We void endAttNum to prevent unused variable warnings.
+ * The if- and for-loop are structured like this to make the compiler
+ * unroll the loop and detect only one single iteration. We need `break`
+ * in the following code block, so just a plain 'if' statement would
+ * not work.
+ */
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+/*
+ * Simplified (optimized) variant of index_getattr specialized for extracting
+ * only the first attribute: cache offset is guaranteed to be 0, and as such
+ * no cache is required.
+ */
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	(IndexTupleHasNulls(itup) && att_isnull(0, (char *)(itup) + sizeof(IndexTupleData))) ? \
+	( \
+		(NBTS_MAKE_NAME(itup, isNull)) = true, \
+		(Datum)NULL \
+	) \
+	: \
+	( \
+		(NBTS_MAKE_NAME(itup, isNull) = false), \
+		(Datum) fetchatt(TupleDescAttr((tupDesc), 0), \
+		(char *) (itup) + IndexInfoFindDataOffset((itup)->t_info)) \
+	) \
+)
+
+#define nbts_attiter_curattisnull(tuple) \
+	NBTS_MAKE_NAME(tuple, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_COLUMN
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
  */
-- 
2.30.2

From b3b10f8b583fb3bf05d7055c2b1319128e596c63 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:54:52 +0200
Subject: [PATCH v5 3/8] Specialize the nbtree rd_indam entry.

Because each rd_indam struct is seperately allocated for each index, we can
freely modify it at runtime without impacting other indexes of the same
access method. For btinsert (which effectively only calls _bt_insert) it is
useful to specialize that function, which also makes rd_indam->aminsert a
good signal whether or not the indexRelation has been fully optimized yet.
---
 src/backend/access/nbtree/nbtree.c    |  7 +++++++
 src/backend/access/nbtree/nbtsearch.c |  2 ++
 src/backend/access/nbtree/nbtsort.c   |  2 ++
 src/include/access/nbtree.h           | 14 ++++++++++++++
 4 files changed, 25 insertions(+)

diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 1481db4dcf..2ce996a0f5 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -160,6 +160,8 @@ btbuildempty(Relation index)
 	metapage = (Page) palloc(BLCKSZ);
 	_bt_initmetapage(metapage, P_NONE, 0, _bt_allequalimage(index, false));
 
+	nbt_opt_specialize(index);
+
 	/*
 	 * Write the page and log it.  It might seem that an immediate sync would
 	 * be sufficient to guarantee that the file exists on disk, but recovery
@@ -322,6 +324,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -764,6 +768,7 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 {
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
+	nbt_opt_specialize(info->index);
 
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
@@ -797,6 +802,8 @@ btvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
 	if (info->analyze_only)
 		return stats;
 
+	nbt_opt_specialize(info->index);
+
 	/*
 	 * If btbulkdelete was called, we need not do anything (we just maintain
 	 * the information used within _bt_vacuum_needs_cleanup() by calling
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index e81eee9c35..d5152bfcb7 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -181,6 +181,8 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
+	nbt_opt_specialize(scan->indexRelation);
+
 	pgstat_count_index_scan(rel);
 
 	/*
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 3558b2d3da..521a2a33c5 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -305,6 +305,8 @@ btbuild(Relation heap, Relation index, IndexInfo *indexInfo)
 	BTBuildState buildstate;
 	double		reltuples;
 
+	nbt_opt_specialize(index);
+
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
 		ResetUsage();
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 83e0dbab16..489b623663 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1132,6 +1132,19 @@ typedef struct BTOptions
 
 #ifdef NBTS_ENABLED
 
+/*
+ * Replace the functions in the rd_indam struct with a variant optimized for
+ * our key shape, if not already done.
+ *
+ * It only needs to be done once for every index relation loaded, so it's
+ * quite unlikely we need to do this and thus marked unlikely().
+ */
+#define nbt_opt_specialize(rel) \
+do { \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert)) \
+		_bt_specialize(rel); \
+} while (false)
+
 /*
  * Access a specialized nbtree function, based on the shape of the index key.
  */
@@ -1143,6 +1156,7 @@ typedef struct BTOptions
 
 #else /* not defined NBTS_ENABLED */
 
+#define nbt_opt_specialize(rel)
 #define NBT_SPECIALIZE_CALL(function, rel, ...) function(__VA_ARGS__)
 
 #endif /* NBTS_ENABLED */
-- 
2.30.2

From 09f5afd1c2b6784a462eb40910b6a71ba3480dd8 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Sun, 30 Jan 2022 16:23:31 +0100
Subject: [PATCH v5 1/8] Specialize nbtree functions on btree key shape

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, initially splitting splitting out
(not yet: specializing) the attcacheoff-capable case.

Note that we generate N specialized functions and 1 'default' function for each
specializable function.

This feature can be disabled by removing the #define NBTS_ENABLED -line in nbtree.h
---
 src/backend/access/nbtree/README           |  22 +
 src/backend/access/nbtree/nbtdedup.c       | 300 +------
 src/backend/access/nbtree/nbtdedup_spec.h  | 313 +++++++
 src/backend/access/nbtree/nbtinsert.c      | 572 +-----------
 src/backend/access/nbtree/nbtinsert_spec.h | 569 ++++++++++++
 src/backend/access/nbtree/nbtpage.c        |   4 +-
 src/backend/access/nbtree/nbtree.c         |  31 +-
 src/backend/access/nbtree/nbtree_spec.h    |  50 ++
 src/backend/access/nbtree/nbtsearch.c      | 994 +--------------------
 src/backend/access/nbtree/nbtsearch_spec.h | 994 +++++++++++++++++++++
 src/backend/access/nbtree/nbtsort.c        | 271 +-----
 src/backend/access/nbtree/nbtsort_spec.h   | 275 ++++++
 src/backend/access/nbtree/nbtsplitloc.c    |  14 +-
 src/backend/access/nbtree/nbtutils.c       | 755 +---------------
 src/backend/access/nbtree/nbtutils_spec.h  | 772 ++++++++++++++++
 src/backend/utils/sort/tuplesort.c         |   4 +-
 src/include/access/nbtree.h                |  61 +-
 src/include/access/nbtree_specialize.h     | 204 +++++
 src/include/access/nbtree_specialized.h    |  67 ++
 19 files changed, 3357 insertions(+), 2915 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.h
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.h
 create mode 100644 src/backend/access/nbtree/nbtree_spec.h
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.h
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.h
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.h
 create mode 100644 src/include/access/nbtree_specialize.h
 create mode 100644 src/include/access/nbtree_specialized.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 5529afc1fe..3c08888c23 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1041,6 +1041,28 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+
+Notes about nbtree call specialization
+--------------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes.
+We can avoid it by specializing performance-sensitive search functions
+and calling those selectively.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.  This performance benefit is at the cost
+of binary size, so this feature can be disabled by defining NBTS_DISABLED.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - single-column indexes
+   NB: The code paths of this optimization do not support multiple key columns.
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also used for the default case, and is slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 0207421a5d..d7025d8e1c 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,259 +22,16 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
-			   Size newitemsz, bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple, and actually update the page.  Else
-			 * reset the state and move on without modifying the page.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
 
 /*
  * Perform bottom-up index deletion pass.
@@ -373,7 +130,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 			/* itup starts first pending interval */
 			_bt_dedup_start_pending(state, itup, offnum);
 		}
-		else if (_bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+		else if (nbts_call(_bt_keep_natts_fast, rel, state->base, itup) > nkeyatts &&
 				 _bt_dedup_save_htid(state, itup))
 		{
 			/* Tuple is equal; just added its TIDs to pending interval */
@@ -748,55 +505,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.h b/src/backend/access/nbtree/nbtdedup_spec.h
new file mode 100644
index 0000000000..27e5a7e686
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.h
@@ -0,0 +1,313 @@
+/*
+ * Specialized functions included in nbtdedup.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static bool NBTS_FUNCTION(_bt_do_singleval)(Relation rel, Page page, BTDedupState state,
+											OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+NBTS_FUNCTION(_bt_do_singleval)(Relation rel, Page page, BTDedupState state,
+								OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (nbts_call(_bt_keep_natts_fast, rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (nbts_call(_bt_keep_natts_fast, rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
+
+#endif /* ifndef NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+NBTS_FUNCTION(_bt_dedup_pass)(Relation rel, Buffer buf, Relation heapRel,
+							  IndexTuple newitem, Size newitemsz,
+							  bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				 minoff,
+				 maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = nbts_call(_bt_do_singleval, rel, page, state,
+								   minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 nbts_call(_bt_keep_natts_fast, rel, state->base, itup) > nkeyatts &&
+						   _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple, and actually update the page.  Else
+			 * reset the state and move on without modifying the page.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index f6f4af8bfe..ec6c73d1cc 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,18 +30,13 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
-static void _bt_stepright(Relation rel, BTInsertState insertstate, BTStack stack);
+static void _bt_stepright(Relation rel,
+										 BTInsertState insertstate,
+										 BTStack stack);
 static void _bt_insertonpg(Relation rel, BTScanInsert itup_key,
 						   Buffer buf,
 						   Buffer cbuf,
@@ -73,311 +68,10 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
-					   itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
-					  NULL);
-}
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -438,7 +132,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = nbts_call(_bt_binsrch_insert, rel, insertstate);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -483,7 +177,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset) < 0);
 				break;
 			}
 
@@ -508,7 +202,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (nbts_call(_bt_compare, rel, itup_key, page, offset) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -722,7 +416,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -769,246 +463,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
-					break;
-
-				_bt_stepright(rel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1649,7 +1103,7 @@ _bt_split(Relation rel, BTScanInsert itup_key, Buffer buf, Buffer cbuf,
 				lastleft = nposting;
 		}
 
-		lefthighkey = _bt_truncate(rel, lastleft, firstright, itup_key);
+		lefthighkey = nbts_call(_bt_truncate, rel, lastleft, firstright, itup_key);
 		itemsz = IndexTupleSize(lefthighkey);
 	}
 	else
@@ -2764,8 +2218,8 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 
 	/* Perform deduplication pass (when enabled and index-is-allequalimage) */
 	if (BTGetDeduplicateItems(rel) && itup_key->allequalimage)
-		_bt_dedup_pass(rel, buffer, heapRel, insertstate->itup,
-					   insertstate->itemsz, (indexUnchanged || uniquedup));
+		nbts_call(_bt_dedup_pass, rel, buffer, heapRel, insertstate->itup,
+				  insertstate->itemsz, (indexUnchanged || uniquedup));
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtinsert_spec.h b/src/backend/access/nbtree/nbtinsert_spec.h
new file mode 100644
index 0000000000..97c866aea3
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.h
@@ -0,0 +1,569 @@
+/*
+ * Specialized functions for nbtinsert.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static BTStack NBTS_FUNCTION(_bt_search_insert)(Relation rel,
+												BTInsertState insertstate);
+
+static OffsetNumber NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
+													 BTInsertState insertstate,
+													 bool checkingunique,
+													 bool indexUnchanged,
+													 BTStack stack,
+													 Relation heapRel);
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				nbts_call(_bt_compare, rel, insertstate->itup_key, page, P_HIKEY) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return nbts_call(_bt_search, rel, insertstate->itup_key,
+					 &insertstate->buf, BT_WRITE, NULL);
+}
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
+								 BTInsertState insertstate,
+								 bool checkingunique,
+								 bool indexUnchanged,
+								 BTStack stack,
+								 Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0)
+					break;
+
+				_bt_stepright(rel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	Assert(P_RIGHTMOST(opaque) ||
+		   nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0);
+
+	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
+
+#endif /* ifndef NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+NBTS_FUNCTION(_bt_doinsert)(Relation rel, IndexTuple itup,
+							IndexUniqueCheck checkUnique,
+							bool indexUnchanged,
+							Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = nbts_call(_bt_mkscankey, rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = nbts_call(_bt_search_insert, rel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = nbts_call(_bt_findinsertloc, rel, &insertstate, checkingunique,
+							   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
+					   itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 8b96708b3e..70304c793d 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1967,10 +1967,10 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 				}
 
 				/* we need an insertion scan key for the search, so build one */
-				itup_key = _bt_mkscankey(rel, targetkey);
+				itup_key = nbts_call(_bt_mkscankey, rel, targetkey);
 				/* find the leftmost leaf page with matching pivot/high key */
 				itup_key->pivotsearch = true;
-				stack = _bt_search(rel, itup_key, &sleafbuf, BT_READ, NULL);
+				stack = nbts_call(_bt_search, rel, itup_key, &sleafbuf, BT_READ, NULL);
 				/* won't need a second lock or pin on leafbuf */
 				_bt_relbuf(rel, sleafbuf);
 
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index b52eca8f38..1481db4dcf 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,10 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -177,33 +181,6 @@ btbuildempty(Relation index)
 	smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
diff --git a/src/backend/access/nbtree/nbtree_spec.h b/src/backend/access/nbtree/nbtree_spec.h
new file mode 100644
index 0000000000..4c342287f6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.h
@@ -0,0 +1,50 @@
+/*
+ * Specialized functions for nbtree.c
+ */
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+NBTS_FUNCTION(_bt_specialize)(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	nbts_call_norel(_bt_specialize, rel, rel);
+#else
+	rel->rd_indam->aminsert = NBTS_FUNCTION(btinsert);
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+NBTS_FUNCTION(btinsert)(Relation rel, Datum *values, bool *isnull,
+						ItemPointer ht_ctid, Relation heapRel,
+						IndexUniqueCheck checkUnique,
+						bool indexUnchanged,
+						IndexInfo *indexInfo)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	nbts_call_norel(_bt_specialize, rel, rel);
+
+	return nbts_call(btinsert, rel, values, isnull, ht_ctid, heapRel,
+					 checkUnique, indexUnchanged, indexInfo);
+#else
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = nbts_call(_bt_doinsert, rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+#endif
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index c74543bfde..e81eee9c35 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,11 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -46,6 +43,9 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -70,493 +70,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- */
-BTStack
-_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
-		   Snapshot snapshot)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split
- * is completed.  'stack' is only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  Snapshot snapshot)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		page = BufferGetPage(buf);
-		TestForOldSnapshot(snapshot, rel, page);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-			break;
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
-		{
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-			break;
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-			high = mid;
-	}
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-		{
-			high = mid;
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
 
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
@@ -625,217 +138,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-			return result;
-
-		scankey++;
-	}
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -1363,7 +665,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	 * Use the manufactured insertion scan key to descend the tree and
 	 * position ourselves on the target leaf page.
 	 */
-	stack = _bt_search(rel, &inskey, &buf, BT_READ, scan->xs_snapshot);
+	stack = nbts_call(_bt_search, rel, &inskey, &buf, BT_READ, scan->xs_snapshot);
 
 	/* don't need to keep the stack around... */
 	_bt_freestack(stack);
@@ -1392,7 +694,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
@@ -1422,9 +724,9 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	/*
 	 * Now load data from the first page of the scan.
 	 */
-	if (!_bt_readpage(scan, dir, offnum))
+	if (!nbts_call_norel(_bt_readpage, scan->indexRelation, scan, dir, offnum))
 	{
-		/*
+		/*`
 		 * There's no actually-matching data on this page.  Try to advance to
 		 * the next page.  Return false if there's no matching data at all.
 		 */
@@ -1498,280 +800,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2014,7 +1042,8 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 				PredicateLockPage(rel, blkno, scan->xs_snapshot);
 				/* see if there are any matches on this page */
 				/* note that this will clear moreRight if we can stop */
-				if (_bt_readpage(scan, dir, P_FIRSTDATAKEY(opaque)))
+				if (nbts_call_norel(_bt_readpage, scan->indexRelation,
+										scan, dir, P_FIRSTDATAKEY(opaque)))
 					break;
 			}
 			else if (scan->parallel_scan != NULL)
@@ -2116,7 +1145,8 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 				PredicateLockPage(rel, BufferGetBlockNumber(so->currPos.buf), scan->xs_snapshot);
 				/* see if there are any matches on this page */
 				/* note that this will clear moreLeft if we can stop */
-				if (_bt_readpage(scan, dir, PageGetMaxOffsetNumber(page)))
+				if (nbts_call_norel(_bt_readpage, scan->indexRelation, scan,
+										dir, PageGetMaxOffsetNumber(page)))
 					break;
 			}
 			else if (scan->parallel_scan != NULL)
@@ -2448,7 +1478,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	/*
 	 * Now load data from the first page of the scan.
 	 */
-	if (!_bt_readpage(scan, dir, start))
+	if (!nbts_call_norel(_bt_readpage, scan->indexRelation, scan, dir, start))
 	{
 		/*
 		 * There's no actually-matching data on this page.  Try to advance to
diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
new file mode 100644
index 0000000000..73d5370496
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -0,0 +1,994 @@
+/*
+ * Specialized functions for nbtsearch.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel, BTScanInsert key,
+											   Buffer buf);
+static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
+										OffsetNumber offnum);
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+NBTS_FUNCTION(_bt_binsrch)(Relation rel,
+						   BTScanInsert key,
+						   Buffer buf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = nbts_call(_bt_compare, rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+			high = mid;
+	}
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
+							OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (nbts_call(_bt_checkkeys, scan->indexRelation, scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			nbts_call(_bt_checkkeys, scan->indexRelation, scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = nbts_call(_bt_checkkeys, scan->indexRelation,
+									 scan, itup, indnatts, dir,
+									 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
+
+#endif /* NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ */
+BTStack
+NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
+						  int access, Snapshot snapshot)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = nbts_call(_bt_moveright, rel, key, *bufP,
+						  (access == BT_WRITE), stack_in,
+						  page_access, snapshot);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = nbts_call(_bt_binsrch, rel, key, *bufP);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = nbts_call(_bt_moveright, rel, key, *bufP, true, stack_in,
+						  BT_WRITE, snapshot);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split
+ * is completed.  'stack' is only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ */
+Buffer
+NBTS_FUNCTION(_bt_moveright)(Relation rel,
+							 BTScanInsert key,
+							 Buffer buf,
+							 bool forupdate,
+							 BTStack stack,
+							 int access,
+							 Snapshot snapshot)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		page = BufferGetPage(buf);
+		TestForOldSnapshot(snapshot, rel, page);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+			break;
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY) >= cmpval)
+		{
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+			break;
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = nbts_call(_bt_compare, rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+		{
+			high = mid;
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+NBTS_FUNCTION(_bt_compare)(Relation rel,
+						   BTScanInsert key,
+						   Page page,
+						   OffsetNumber offnum)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+	scankey = key->scankeys;
+	for (int i = 1; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+			return result;
+
+		scankey++;
+	}
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index bd1685c441..3558b2d3da 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,9 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
 /*
  *	btbuild() -- build a new btree index.
@@ -566,7 +567,7 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 
 	wstate.heap = btspool->heap;
 	wstate.index = btspool->index;
-	wstate.inskey = _bt_mkscankey(wstate.index, NULL);
+	wstate.inskey = nbts_call(_bt_mkscankey, wstate.index, NULL);
 	/* _bt_mkscankey() won't set allequalimage without metapage */
 	wstate.inskey->allequalimage = _bt_allequalimage(wstate.index, true);
 	wstate.btws_use_wal = RelationNeedsWAL(wstate.index);
@@ -578,7 +579,7 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE,
 								 PROGRESS_BTREE_PHASE_LEAF_LOAD);
-	_bt_load(&wstate, btspool, btspool2);
+	nbts_call_norel(_bt_load, wstate.index, &wstate, btspool, btspool2);
 }
 
 /*
@@ -978,8 +979,8 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 			lastleft = (IndexTuple) PageGetItem(opage, ii);
 
 			Assert(IndexTupleSize(oitup) > last_truncextra);
-			truncated = _bt_truncate(wstate->index, lastleft, oitup,
-									 wstate->inskey);
+			truncated = nbts_call(_bt_truncate, wstate->index, lastleft, oitup,
+								  wstate->inskey);
 			if (!PageIndexTupleOverwrite(opage, P_HIKEY, (Item) truncated,
 										 IndexTupleSize(truncated)))
 				elog(ERROR, "failed to add high key to the index page");
@@ -1176,264 +1177,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			AssertState(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.h b/src/backend/access/nbtree/nbtsort_spec.h
new file mode 100644
index 0000000000..8f4a3602ca
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.h
@@ -0,0 +1,275 @@
+/*
+ * Specialized functions included in nbtsort.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static void NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
+									BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
+						BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			AssertState(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (nbts_call(_bt_keep_natts_fast, wstate->index, dstate->base,
+							   itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
+
+#endif
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index 241e26d338..8e5337cad7 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -692,7 +692,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	{
 		itemid = PageGetItemId(state->origpage, maxoff);
 		tup = (IndexTuple) PageGetItem(state->origpage, itemid);
-		keepnatts = _bt_keep_natts_fast(state->rel, tup, state->newitem);
+		keepnatts = nbts_call(_bt_keep_natts_fast, state->rel, tup, state->newitem);
 
 		if (keepnatts > 1 && keepnatts <= nkeyatts)
 		{
@@ -723,7 +723,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 		!_bt_adjacenthtid(&tup->t_tid, &state->newitem->t_tid))
 		return false;
 	/* Check same conditions as rightmost item case, too */
-	keepnatts = _bt_keep_natts_fast(state->rel, tup, state->newitem);
+	keepnatts = nbts_call(_bt_keep_natts_fast, state->rel, tup, state->newitem);
 
 	if (keepnatts > 1 && keepnatts <= nkeyatts)
 	{
@@ -972,7 +972,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 	 * avoid appending a heap TID in new high key, we're done.  Finish split
 	 * with default strategy and initial split interval.
 	 */
-	perfectpenalty = _bt_keep_natts_fast(state->rel, leftmost, rightmost);
+	perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, leftmost, rightmost);
 	if (perfectpenalty <= indnkeyatts)
 		return perfectpenalty;
 
@@ -993,7 +993,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 	 * If page is entirely full of duplicates, a single value strategy split
 	 * will be performed.
 	 */
-	perfectpenalty = _bt_keep_natts_fast(state->rel, leftmost, rightmost);
+	perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, leftmost, rightmost);
 	if (perfectpenalty <= indnkeyatts)
 	{
 		*strategy = SPLIT_MANY_DUPLICATES;
@@ -1031,8 +1031,8 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 
 		itemid = PageGetItemId(state->origpage, P_HIKEY);
 		hikey = (IndexTuple) PageGetItem(state->origpage, itemid);
-		perfectpenalty = _bt_keep_natts_fast(state->rel, hikey,
-											 state->newitem);
+		perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, hikey,
+								   state->newitem);
 		if (perfectpenalty <= indnkeyatts)
 			*strategy = SPLIT_SINGLE_VALUE;
 		else
@@ -1154,7 +1154,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 	lastleft = _bt_split_lastleft(state, split);
 	firstright = _bt_split_firstright(state, split);
 
-	return _bt_keep_natts_fast(state->rel, lastleft, firstright);
+	return nbts_call(_bt_keep_natts_fast, state->rel, lastleft, firstright);
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index ff260c393a..bc443ebd27 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,11 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1221,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1704,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
new file mode 100644
index 0000000000..a4b934ae7a
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.h
@@ -0,0 +1,772 @@
+/*
+ * Specialized functions included in nbtutils.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static bool NBTS_FUNCTION(_bt_check_rowcompare)(ScanKey skey,
+												IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+												ScanDirection dir, bool *continuescan);
+
+static int	NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
+										  IndexTuple firstright, BTScanInsert itup_key);
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+NBTS_FUNCTION(_bt_check_rowcompare)(ScanKey skey, IndexTuple tuple,
+									int tupnatts, TupleDesc tupdesc,
+									ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
+							  IndexTuple firstright, BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == nbts_call(_bt_keep_natts_fast, rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+#endif /* NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+NBTS_FUNCTION(_bt_checkkeys)(Relation rel, IndexScanDesc scan,
+							 IndexTuple tuple, int tupnatts,
+							 ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (nbts_call_norel(_bt_check_rowcompare, rel, key, tuple,
+								tupnatts, tupdesc, dir, continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+NBTS_FUNCTION(_bt_truncate)(Relation rel, IndexTuple lastleft,
+							IndexTuple firstright, BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = nbts_call(_bt_keep_natts, rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel,
+								   IndexTuple lastleft,
+								   IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 421afcf47d..7f398bd4eb 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -1153,7 +1153,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 
 	state->tupDesc = tupDesc;	/* assume we need not copy tupDesc */
 
-	indexScanKey = _bt_mkscankey(indexRel, NULL);
+	indexScanKey = nbts_call(_bt_mkscankey, indexRel, NULL);
 
 	if (state->indexInfo->ii_Expressions != NULL)
 	{
@@ -1251,7 +1251,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	state->enforceUnique = enforceUnique;
 	state->uniqueNullsNotDistinct = uniqueNullsNotDistinct;
 
-	indexScanKey = _bt_mkscankey(indexRel, NULL);
+	indexScanKey = nbts_call(_bt_mkscankey, indexRel, NULL);
 
 	/* Prepare SortSupport data for each column */
 	state->sortKeys = (SortSupport) palloc0(state->nKeys *
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 93f8267b48..83e0dbab16 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1116,15 +1116,47 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+
+
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define NBTS_ENABLED
+
+#ifdef NBTS_ENABLED
+
+/*
+ * Access a specialized nbtree function, based on the shape of the index key.
+ */
+
+#define NBT_SPECIALIZE_CALL(function, rel, ...) \
+( \
+	NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+)
+
+#else /* not defined NBTS_ENABLED */
+
+#define NBT_SPECIALIZE_CALL(function, rel, ...) function(__VA_ARGS__)
+
+#endif /* NBTS_ENABLED */
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specialized.h"
+#include "nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1155,9 +1187,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
-						   IndexTuple newitem, Size newitemsz,
-						   bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1173,9 +1202,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Buffer lbuf, BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, BTStack stack, BlockNumber child);
 
@@ -1223,12 +1249,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
-						  int access, Snapshot snapshot);
-extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
@@ -1237,7 +1257,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1245,8 +1264,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1259,10 +1276,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
new file mode 100644
index 0000000000..23fdda4f0e
--- /dev/null
+++ b/src/include/access/nbtree_specialize.h
@@ -0,0 +1,204 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_call(function, indexrel, ...rest_of_args), and
+ *   nbts_call_norel(function, indexrel, ...args)
+ *     This will call the specialized variant of 'function' based on the index
+ *     relation data.
+ *     The difference between nbts_call and nbts_call_norel is that _call
+ *     uses indexrel as first argument in the function call, whereas
+ *     nbts_call_norel does not.
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ *
+ * example usage:
+ *
+ * kwithnulls = nbts_call_norel(_bt_key_hasnulls, myindex, mytuple, tupDesc);
+ *
+ * NBTS_FUNCTION(_bt_key_hasnulls)(IndexTuple mytuple, TupleDesc tupDesc)
+ * {
+ *    nbts_attiterdeclare(mytuple);
+ *    nbts_attiterinit(mytuple, 1, tupDesc);
+ *    nbts_foreachattr(1, 10)
+ *    {
+ *        Datum it = nbts_attiter_nextattdatum(tuple, tupDesc);
+ *        if (nbts_attiter_curattisnull(tuple))
+ *           return true;
+ *    }
+ *    return false
+ * }
+ */
+
+/*
+ * Call a potentially specialized function for a given btree operation.
+ *
+ * NB: the rel argument is evaluated multiple times.
+ */
+#define nbts_call(name, rel, ...) \
+	nbts_call_norel(name, (rel), (rel), __VA_ARGS__)
+
+#ifdef NBTS_ENABLED
+
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+#ifdef nbts_call_norel
+#undef nbts_call_norel
+#endif
+
+#define nbts_call_norel(name, rel, ...) \
+	(NBTS_FUNCTION(name)(__VA_ARGS__))
+
+/*
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_CACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/* reset call to SPECIALIZE_CALL for default behaviour */
+#undef nbts_call_norel
+#define nbts_call_norel(name, rel, ...) \
+	NBT_SPECIALIZE_CALL(name, (rel), __VA_ARGS__)
+
+/*
+ * "Default", externally accessible, not so much optimized functions
+ */
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+/* for the default functions, we want to use the unspecialized name. */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) name
+
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/* from here on there are no more NBTS_FUNCTIONs */
+#undef NBTS_FUNCTION
+
+#else /* not defined NBTS_ENABLED */
+
+/*
+ * NBTS_ENABLE is not defined, so we don't want to use the specializations.
+ * We revert to the behaviour from PG14 and earlier, which only uses
+ * attcacheoff.
+ */
+
+#define NBTS_FUNCTION(name) name
+
+#define nbts_call_norel(name, rel, ...) \
+	name(__VA_ARGS__)
+
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+
+#endif /* !NBTS_ENABLED */
diff --git a/src/include/access/nbtree_specialized.h b/src/include/access/nbtree_specialized.h
new file mode 100644
index 0000000000..c45fa84aed
--- /dev/null
+++ b/src/include/access/nbtree_specialized.h
@@ -0,0 +1,67 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void
+NBTS_FUNCTION(_bt_specialize)(Relation rel);
+
+extern bool
+NBTS_FUNCTION(btinsert)(Relation rel, Datum *values, bool *isnull,
+						ItemPointer ht_ctid, Relation heapRel,
+						IndexUniqueCheck checkUnique,
+						bool indexUnchanged,
+						struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void
+NBTS_FUNCTION(_bt_dedup_pass)(Relation rel, Buffer buf, Relation heapRel,
+							  IndexTuple newitem, Size newitemsz,
+							  bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool
+NBTS_FUNCTION(_bt_doinsert)(Relation rel, IndexTuple itup,
+							IndexUniqueCheck checkUnique, bool indexUnchanged,
+							Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack
+NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key,
+						  Buffer *bufP, int access,
+						  Snapshot snapshot);
+extern Buffer
+NBTS_FUNCTION(_bt_moveright)(Relation rel, BTScanInsert key, Buffer buf,
+							 bool forupdate, BTStack stack, int access,
+							 Snapshot snapshot);
+extern OffsetNumber
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate);
+extern int32
+NBTS_FUNCTION(_bt_compare)(Relation rel, BTScanInsert key,
+						   Page page, OffsetNumber offnum);
+
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert
+NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup);
+extern bool
+NBTS_FUNCTION(_bt_checkkeys)(Relation rel, IndexScanDesc scan,
+							 IndexTuple tuple, int tupnatts,
+							 ScanDirection dir, bool *continuescan);
+extern IndexTuple
+NBTS_FUNCTION(_bt_truncate)(Relation rel, IndexTuple lastleft,
+							IndexTuple firstright, BTScanInsert itup_key);
+extern int
+NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel, IndexTuple lastleft,
+								   IndexTuple firstright);
-- 
2.30.2

From 303a4dd46705aa9aef49d0cc92ed66a49c16cd79 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:51:01 +0200
Subject: [PATCH v5 5/8] Add a function whose task it is to populate all
 attcacheoff-s of a TupleDesc's attributes

It fills uncacheable offsets with -2; as opposed to -1 which signals
"unknown", thus allowing users of the API to determine the cache-ability
of an attribute at O(1) complexity after this one-time O(n) cost, as
opposed to the repeated O(n) cost that currently applies.
---
 src/backend/access/common/tupdesc.c | 97 +++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |  2 +
 2 files changed, 99 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index d6fb261e20..af4ef00f2b 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -919,3 +919,100 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid value.
+ *
+ * Sets attcacheoff to -2 for uncacheable attributes (i.e. attributes after a
+ * variable length attributes).
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	i, j;
+
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+	{
+		/*
+		 * Already done the calculations, find the last attribute that has
+		 * cache offset.
+		 */
+		for (i = (AttrNumber) numberOfAttributes; i > 1; i--)
+		{
+			if (TupleDescAttr(desc, i - 1)->attcacheoff != -2)
+				return i;
+		}
+
+		return 1;
+	}
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	i = 1;
+	/*
+	 * Someone might have set some offsets previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (i < numberOfAttributes && TupleDescAttr(desc, i)->attcacheoff > 0)
+		i++;
+
+	/* Cache offset is undetermined. Start calculating offsets if possible */
+	if (i < numberOfAttributes &&
+		TupleDescAttr(desc, i)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, i - 1);
+		Size off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (i < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, i);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+						att->attcacheoff = off;
+					else
+						att->attcacheoff = -2;
+					i++;
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				i++;
+			}
+		} else {
+			if (off == att_align_nominal(off, att->attalign))
+				att->attcacheoff = off;
+			else
+				att->attcacheoff = -2;
+			i++;
+		}
+	}
+
+	/*
+	 * No cacheable offsets left. Fill the rest with -2s, but return the latest
+	 * cached offset.
+	 */
+	j = i;
+
+	while (i < numberOfAttributes)
+	{
+		TupleDescAttr(desc, i)->attcacheoff = -2;
+		i++;
+	}
+
+	return j;
+}
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index 28dd6de18b..219f837875 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.30.2

From efcdd2b73405020b43d43c0e1770ba060baa126a Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Mon, 6 Jun 2022 23:16:18 +0200
Subject: [PATCH v5 8/8] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also have those prefixing attributes that equal the
scankey.

We cannot propagate this information to _binsrch on lower pages,
as this downstream page may concurrently have split and/or have
merged with its deleted left neighbour (see [0]), which moves
the keyspace of the linked page. We thus can only trust the
current state of this current page for this optimization, which
means we must validate this state each time we open the page.

Although this limits the overall applicability of the
performance improvement, it still allows for a nice performance
improvement in most cases where initial columns have many
duplicate values and a compare function that is not cheap.

Additionally, most of the time a pages' highkey is equal to the
right seperator on the parent page. By storing this seperator
and doing a binary equality check, we can cheaply validate the
highkey on a page, which also allows us to carry over the
right seperators' prefix into the page.
---
 contrib/amcheck/verify_nbtree.c            |  17 +--
 src/backend/access/nbtree/README           |  25 +++++
 src/backend/access/nbtree/nbtinsert.c      |  14 ++-
 src/backend/access/nbtree/nbtinsert_spec.h |  22 ++--
 src/backend/access/nbtree/nbtsearch.c      |   3 +-
 src/backend/access/nbtree/nbtsearch_spec.h | 115 ++++++++++++++++++---
 src/include/access/nbtree_specialized.h    |   9 +-
 7 files changed, 169 insertions(+), 36 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 2beeebb163..8c4215372a 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2700,6 +2700,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2709,13 +2710,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2777,6 +2778,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2787,7 +2789,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2839,10 +2841,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2862,10 +2865,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2900,13 +2904,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 3c08888c23..13ac9ee2be 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,31 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+potentially saving cycles.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by an inner page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. (2,2) to (1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+The positive part of this, is that we already have results of the highest
+value of a page: a pages' highkey is compared to the scankey while we have
+a pin on the page in the _bt_moveright procedure. The _bt_binsrch procedure
+will use this result as a rightmost prefix compare, and for each step in the
+binary search (that does not compare less than the insert key) improve the
+equal-prefix bounds.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index ec6c73d1cc..20e5f33f98 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -132,7 +132,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = nbts_call(_bt_binsrch_insert, rel, insertstate);
+	offset = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -142,6 +142,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -177,7 +179,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset) < 0);
+				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset,
+								 &cmpcol) < 0);
 				break;
 			}
 
@@ -202,7 +205,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (nbts_call(_bt_compare, rel, itup_key, page, offset) != 0)
+					if (nbts_call(_bt_compare, rel, itup_key, page, offset,
+								  &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -412,11 +416,13 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY);
+			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY,
+								   &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
diff --git a/src/backend/access/nbtree/nbtinsert_spec.h b/src/backend/access/nbtree/nbtinsert_spec.h
index 97c866aea3..ccba0fa5ed 100644
--- a/src/backend/access/nbtree/nbtinsert_spec.h
+++ b/src/backend/access/nbtree/nbtinsert_spec.h
@@ -73,6 +73,7 @@ NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	comparecol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -91,7 +92,8 @@ NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				nbts_call(_bt_compare, rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				nbts_call(_bt_compare, rel, insertstate->itup_key, page,
+						  P_HIKEY, &comparecol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -221,6 +223,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -238,7 +241,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0)
+					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, insertstate, stack);
@@ -291,6 +294,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -321,7 +325,8 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) != 0 ||
+				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY,
+						  &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -336,10 +341,13 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) || nbts_call(_bt_compare, rel, itup_key,
+												page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -358,7 +366,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index d5152bfcb7..607940bbcd 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -178,6 +178,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	AttrNumber	attno = 1;
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -696,7 +697,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf);
+	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf, &attno);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
index a5c5f2b94f..19a6178334 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.h
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -10,8 +10,10 @@
  */
 #ifndef NBTS_SPECIALIZING_DEFAULT
 
-static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel, BTScanInsert key,
-											   Buffer buf);
+static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel,
+											   BTScanInsert key,
+											   Buffer buf,
+											   AttrNumber *highkeycmpcol);
 static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
 										OffsetNumber offnum);
 
@@ -38,7 +40,8 @@ static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
 static OffsetNumber
 NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 						   BTScanInsert key,
-						   Buffer buf)
+						   Buffer buf,
+						   AttrNumber *highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -46,6 +49,8 @@ NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -87,17 +92,26 @@ NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = nbts_call(_bt_compare, rel, key, page, mid);
+		result = nbts_call(_bt_compare, rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
 
+	*highkeycmpcol = highcmpcol;
+
 	/*
 	 * At this point we have high == low, but be careful: they could point
 	 * past the last slot on the page.
@@ -423,6 +437,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
 
 	/* Get the root page to start with */
 	*bufP = _bt_getroot(rel, access);
@@ -441,6 +456,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		IndexTuple	itup;
 		BlockNumber child;
 		BTStack		new_stack;
+		AttrNumber	highkeycmpcol = 1;
 
 		/*
 		 * Race -- the page we just grabbed may have split since we read its
@@ -456,7 +472,8 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 */
 		*bufP = nbts_call(_bt_moveright, rel, key, *bufP,
 						  (access == BT_WRITE), stack_in,
-						  page_access, snapshot);
+						  page_access, snapshot, &highkeycmpcol,
+						  (char *) tupdatabuf);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -468,12 +485,17 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = nbts_call(_bt_binsrch, rel, key, *bufP);
+		offnum = nbts_call(_bt_binsrch, rel, key, *bufP, &highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		if (highkeycmpcol > 1)
+		{
+			memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+		}
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -507,6 +529,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		AttrNumber highkeycmpcol = 1;
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -517,7 +540,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = nbts_call(_bt_moveright, rel, key, *bufP, true, stack_in,
-						  BT_WRITE, snapshot);
+						  BT_WRITE, snapshot, &highkeycmpcol, (char *) tupdatabuf);
 	}
 
 	return stack_in;
@@ -565,12 +588,16 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 							 bool forupdate,
 							 BTStack stack,
 							 int access,
-							 Snapshot snapshot)
+							 Snapshot snapshot,
+							 AttrNumber *comparecol,
+							 char *tupdatabuf)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
+	Assert(PointerIsValid(comparecol));
+
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
 	 * this page is > the high key stored on the page, then the page has split
@@ -592,12 +619,17 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -623,14 +655,49 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY) >= cmpval)
+		/*
+		 * When comparecol is > 1, tupdatabuf is filled with the right seperator
+		 * of the parent node. This allows us to do a binary equality check
+		 * between the parent node's right seperator (which is < key) and this
+		 * page's P_HIKEY. If they equal, we can reuse the result of the
+		 * parent node's rightkey compare, which means we can potentially save
+		 * a full key compare.
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, with this optimization we can
+		 * skip one of those.
+		 * 
+		 * 3: 1 for the highkey (rightmost), and on average 2 before we move
+		 * right in the binary search on the page.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			}
+		}
+
+		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY,
+										  &cmpcol) >= cmpval)
 		{
 			/* step right one page */
+			*comparecol = 1;
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -663,7 +730,8 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
  * list split).
  */
 OffsetNumber
-NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate,
+								  AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -673,6 +741,7 @@ NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -723,16 +792,21 @@ NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = nbts_call(_bt_compare, rel, key, page, mid);
+		result = nbts_call(_bt_compare, rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -813,7 +887,8 @@ int32
 NBTS_FUNCTION(_bt_compare)(Relation rel,
 						   BTScanInsert key,
 						   Page page,
-						   OffsetNumber offnum)
+						   OffsetNumber offnum,
+						   AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -854,10 +929,11 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	nbts_attiterinit(itup, 1, itupdesc);
 
-	nbts_foreachattr(1, ncmpkey)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+	scankey = key->scankeys + ((*comparecol) - 1);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
 
@@ -902,11 +978,20 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = nbts_attiter_attnum;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
diff --git a/src/include/access/nbtree_specialized.h b/src/include/access/nbtree_specialized.h
index c45fa84aed..ddceb4a4aa 100644
--- a/src/include/access/nbtree_specialized.h
+++ b/src/include/access/nbtree_specialized.h
@@ -43,12 +43,15 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key,
 extern Buffer
 NBTS_FUNCTION(_bt_moveright)(Relation rel, BTScanInsert key, Buffer buf,
 							 bool forupdate, BTStack stack, int access,
-							 Snapshot snapshot);
+							 Snapshot snapshot, AttrNumber *comparecol,
+							 char *tupdatabuf);
 extern OffsetNumber
-NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate);
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate,
+								  AttrNumber highcmpcol);
 extern int32
 NBTS_FUNCTION(_bt_compare)(Relation rel, BTScanInsert key,
-						   Page page, OffsetNumber offnum);
+						   Page page, OffsetNumber offnum,
+						   AttrNumber *comparecol);
 
 /*
  * prototypes for functions in nbtutils_spec.h
-- 
2.30.2

From 3a3b346c80bfafb094f296c2ab15c86063deb2b5 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 21 Apr 2022 16:22:07 +0200
Subject: [PATCH v5 7/8] Add specialization to btree index creation.

This was an oversight that is corrected easily; but an oversight nonetheless.
This increases the (re)build performance of indexes by another few percents.
---
 src/backend/utils/sort/tuplesort.c      | 147 ++---------------------
 src/backend/utils/sort/tuplesort_nbts.h | 148 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  18 +++
 3 files changed, 175 insertions(+), 138 deletions(-)
 create mode 100644 src/backend/utils/sort/tuplesort_nbts.h

diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 7f398bd4eb..3b96e8d4f8 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -655,8 +655,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int len);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static void copytup_index(Tuplesortstate *state, SortTuple *stup, void *tup);
@@ -679,6 +677,10 @@ static void free_sort_tuple(Tuplesortstate *state, SortTuple *stup);
 static void tuplesort_free(Tuplesortstate *state);
 static void tuplesort_updatemax(Tuplesortstate *state);
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesort_nbts.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
 /*
  * Specialized comparators that we can inline into specialized sorts.  The goal
  * is to try to sort two tuples without having to follow the pointers to the
@@ -1239,7 +1241,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 								sortopt & TUPLESORT_RANDOMACCESS,
 								PARALLEL_SORT(state));
 
-	state->comparetup = comparetup_index_btree;
+	state->comparetup = NBT_SPECIALIZE_NAME(comparetup_index_btree, indexRel);
 	state->copytup = copytup_index;
 	state->writetup = writetup_index;
 	state->readtup = readtup_index;
@@ -1357,7 +1359,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 
 	state->nKeys = IndexRelationGetNumberOfKeyAttributes(indexRel);
 
-	state->comparetup = comparetup_index_btree;
+	state->comparetup = NBT_SPECIALIZE_NAME(comparetup_index_btree, indexRel);
 	state->copytup = copytup_index;
 	state->writetup = writetup_index;
 	state->readtup = readtup_index;
@@ -4321,142 +4323,11 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
  * The btree and hash cases require separate comparison functions, but the
  * IndexTuple representation is the same so the copy/write/read support
  * functions can be shared.
+ *
+ * nbtree function can be found in tuplesort_nbts.h, and is included
+ * through the nbtree specialization functions.
  */
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	SortSupport sortKey = state->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = state->nKeys;
-	tupDes = RelationGetDescr(state->indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (state->enforceUnique && !(!state->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(state->indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(state->indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(state->heapRel,
-									RelationGetRelationName(state->indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesort_nbts.h b/src/backend/utils/sort/tuplesort_nbts.h
new file mode 100644
index 0000000000..d1b2670747
--- /dev/null
+++ b/src/backend/utils/sort/tuplesort_nbts.h
@@ -0,0 +1,148 @@
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static int NBTS_FUNCTION(comparetup_index_btree)(const SortTuple *a,
+												 const SortTuple *b,
+												 Tuplesortstate *state);
+
+static int
+NBTS_FUNCTION(comparetup_index_btree)(const SortTuple *a, const SortTuple *b,
+									  Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	SortSupport sortKey = state->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = state->nKeys;
+	tupDes = RelationGetDescr(state->indexRel);
+
+	if (!sortKey->abbrev_converter)
+	{
+		nkey = 2;
+		sortKey++;
+	}
+	else
+		nkey = 1;
+
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
+	{
+		Datum		datum1,
+					datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+		{
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		}
+		else
+		{
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
+		}
+
+		if (compare != 0)
+			return compare;
+
+		if (nbts_attiter_curattisnull(tuple1))
+			equal_hasnull = true;
+
+		sortKey++;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (state->enforceUnique && !(!state->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(state->indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(state->indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(state->heapRel,
+									   RelationGetRelationName(state->indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
+
+#endif
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 92894e4ea7..11116b47ca 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1170,6 +1170,24 @@ do { \
 	) \
 )
 
+#define NBT_SPECIALIZE_NAME(name, rel) \
+( \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_COLUMN) \
+	) \
+	: \
+	( \
+		TupleDescAttr(RelationGetDescr(rel), \
+					  IndexRelationGetNumberOfKeyAttributes(rel) - 1)->attcacheoff > 0 ? ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+		) \
+		: \
+		( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED) \
+		) \
+	) \
+)
+
 #else /* not defined NBTS_ENABLED */
 
 #define nbt_opt_specialize(rel)
-- 
2.30.2

From 3e558e97598466b79f57c530ff5e56ac9cc20ad4 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:44:01 +0200
Subject: [PATCH v5 6/8] Implement specialized uncacheable attribute iteration

Uses an iterator to prevent doing duplicate work while iterating over
attributes.

Inspiration: https://www.postgresql.org/message-id/CAEze2WjE9ka8i%3Ds-Vv5oShro9xTrt5VQnQvFG9AaRwWpMm3-fg%40mail.gmail.com
---
 src/backend/access/nbtree/nbtree_spec.h |   1 +
 src/include/access/itup_attiter.h       | 198 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  13 +-
 src/include/access/nbtree_specialize.h  |  40 ++++-
 4 files changed, 249 insertions(+), 3 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/backend/access/nbtree/nbtree_spec.h b/src/backend/access/nbtree/nbtree_spec.h
index 4c342287f6..88b01c86f7 100644
--- a/src/backend/access/nbtree/nbtree_spec.h
+++ b/src/backend/access/nbtree/nbtree_spec.h
@@ -9,6 +9,7 @@ void
 NBTS_FUNCTION(_bt_specialize)(Relation rel)
 {
 #ifdef NBTS_SPECIALIZING_DEFAULT
+	PopulateTupleDescCacheOffsets(rel->rd_att);
 	nbts_call_norel(_bt_specialize, rel, rel);
 #else
 	rel->rd_indam->aminsert = NBTS_FUNCTION(btinsert);
diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..9f16a4b3d7
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,198 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 1559399b0e..92894e4ea7 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1122,6 +1123,7 @@ typedef struct BTOptions
  */
 #define NBTS_TYPE_SINGLE_COLUMN single
 #define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_DEFAULT default
 
 
@@ -1152,12 +1154,19 @@ do { \
 
 #define NBT_SPECIALIZE_CALL(function, rel, ...) \
 ( \
-	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? (   \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? ( \
 		NBTS_MAKE_NAME(function, NBTS_TYPE_SINGLE_COLUMN)(__VA_ARGS__) \
 	) \
 	: \
 	( \
-		NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+		TupleDescAttr(RelationGetDescr(rel), \
+					  IndexRelationGetNumberOfKeyAttributes(rel) - 1)->attcacheoff > 0 ? ( \
+			NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+		) \
+		: \
+		( \
+			NBTS_MAKE_NAME(function, NBTS_TYPE_UNCACHED)(__VA_ARGS__) \
+		) \
 	) \
 )
 
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
index 9733a27bdd..efbacf7d67 100644
--- a/src/include/access/nbtree_specialize.h
+++ b/src/include/access/nbtree_specialize.h
@@ -115,7 +115,11 @@
 #define nbts_attiter_nextattdatum(itup, tupDesc) \
 ( \
 	AssertMacro(spec_i == 0), \
-	(IndexTupleHasNulls(itup) && att_isnull(0, (char *)(itup) + sizeof(IndexTupleData))) ? \
+	( \
+		IndexTupleHasNulls(itup) && \
+		att_isnull(0, (bits8 *) ((char *) (itup) + sizeof(IndexTupleData))) \
+	) \
+	? \
 	( \
 		(NBTS_MAKE_NAME(itup, isNull)) = true, \
 		(Datum)NULL \
@@ -175,6 +179,40 @@
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /* reset call to SPECIALIZE_CALL for default behaviour */
 #undef nbts_call_norel
 #define nbts_call_norel(name, rel, ...) \
-- 
2.30.2

From 9b51e105074a776d4bb69afd77a0223e719a4997 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:51:01 +0200
Subject: [PATCH v6 5/8] Add a function whose task it is to populate all
 attcacheoff-s of a TupleDesc's attributes

It fills uncacheable offsets with -2; as opposed to -1 which signals
"unknown", thus allowing users of the API to determine the cache-ability
of an attribute at O(1) complexity after this one-time O(n) cost, as
opposed to the repeated O(n) cost that currently applies.
---
 src/backend/access/common/tupdesc.c | 97 +++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |  2 +
 2 files changed, 99 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index d6fb261e20..af4ef00f2b 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -919,3 +919,100 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid value.
+ *
+ * Sets attcacheoff to -2 for uncacheable attributes (i.e. attributes after a
+ * variable length attributes).
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	i, j;
+
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+	{
+		/*
+		 * Already done the calculations, find the last attribute that has
+		 * cache offset.
+		 */
+		for (i = (AttrNumber) numberOfAttributes; i > 1; i--)
+		{
+			if (TupleDescAttr(desc, i - 1)->attcacheoff != -2)
+				return i;
+		}
+
+		return 1;
+	}
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	i = 1;
+	/*
+	 * Someone might have set some offsets previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (i < numberOfAttributes && TupleDescAttr(desc, i)->attcacheoff > 0)
+		i++;
+
+	/* Cache offset is undetermined. Start calculating offsets if possible */
+	if (i < numberOfAttributes &&
+		TupleDescAttr(desc, i)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, i - 1);
+		Size off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (i < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, i);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+						att->attcacheoff = off;
+					else
+						att->attcacheoff = -2;
+					i++;
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				i++;
+			}
+		} else {
+			if (off == att_align_nominal(off, att->attalign))
+				att->attcacheoff = off;
+			else
+				att->attcacheoff = -2;
+			i++;
+		}
+	}
+
+	/*
+	 * No cacheable offsets left. Fill the rest with -2s, but return the latest
+	 * cached offset.
+	 */
+	j = i;
+
+	while (i < numberOfAttributes)
+	{
+		TupleDescAttr(desc, i)->attcacheoff = -2;
+		i++;
+	}
+
+	return j;
+}
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index 28dd6de18b..219f837875 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.30.2

From 1609509386ef18d5a22ebc79c9075e34573f0640 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 7 Apr 2022 12:47:50 +0200
Subject: [PATCH v6 4/8] Optimize attribute iterator access for single-column
 btree keys

This removes the index_getattr_nocache call path, which has significant overhead.
---
 src/include/access/nbtree.h            |  9 +++-
 src/include/access/nbtree_specialize.h | 63 ++++++++++++++++++++++++++
 2 files changed, 71 insertions(+), 1 deletion(-)

diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 489b623663..1559399b0e 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1120,6 +1120,7 @@ typedef struct BTOptions
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_COLUMN single
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 
@@ -1151,7 +1152,13 @@ do { \
 
 #define NBT_SPECIALIZE_CALL(function, rel, ...) \
 ( \
-	NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? (   \
+		NBTS_MAKE_NAME(function, NBTS_TYPE_SINGLE_COLUMN)(__VA_ARGS__) \
+	) \
+	: \
+	( \
+		NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+	) \
 )
 
 #else /* not defined NBTS_ENABLED */
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
index 23fdda4f0e..9733a27bdd 100644
--- a/src/include/access/nbtree_specialize.h
+++ b/src/include/access/nbtree_specialize.h
@@ -79,6 +79,69 @@
 #define nbts_call_norel(name, rel, ...) \
 	(NBTS_FUNCTION(name)(__VA_ARGS__))
 
+/*
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path may never be used for indexes with multiple key
+ *  columns, because it does not ever continue to a next column.
+ */
+
+#define NBTS_SPECIALIZING_SINGLE_COLUMN
+#define NBTS_TYPE NBTS_TYPE_SINGLE_COLUMN
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+/*
+ * We void endAttNum to prevent unused variable warnings.
+ * The if- and for-loop are structured like this to make the compiler
+ * unroll the loop and detect only one single iteration. We need `break`
+ * in the following code block, so just a plain 'if' statement would
+ * not work.
+ */
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+/*
+ * Simplified (optimized) variant of index_getattr specialized for extracting
+ * only the first attribute: cache offset is guaranteed to be 0, and as such
+ * no cache is required.
+ */
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	(IndexTupleHasNulls(itup) && att_isnull(0, (char *)(itup) + sizeof(IndexTupleData))) ? \
+	( \
+		(NBTS_MAKE_NAME(itup, isNull)) = true, \
+		(Datum)NULL \
+	) \
+	: \
+	( \
+		(NBTS_MAKE_NAME(itup, isNull) = false), \
+		(Datum) fetchatt(TupleDescAttr((tupDesc), 0), \
+		(char *) (itup) + IndexInfoFindDataOffset((itup)->t_info)) \
+	) \
+)
+
+#define nbts_attiter_curattisnull(tuple) \
+	NBTS_MAKE_NAME(tuple, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_COLUMN
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
  */
-- 
2.30.2

From 2e449385053315df3b89019ad8359656fa3cae97 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:54:52 +0200
Subject: [PATCH v6 3/8] Specialize the nbtree rd_indam entry.

Because each rd_indam struct is seperately allocated for each index, we can
freely modify it at runtime without impacting other indexes of the same
access method. For btinsert (which effectively only calls _bt_insert) it is
useful to specialize that function, which also makes rd_indam->aminsert a
good signal whether or not the indexRelation has been fully optimized yet.
---
 src/backend/access/nbtree/nbtree.c    |  7 +++++++
 src/backend/access/nbtree/nbtsearch.c |  2 ++
 src/backend/access/nbtree/nbtsort.c   |  2 ++
 src/include/access/nbtree.h           | 14 ++++++++++++++
 4 files changed, 25 insertions(+)

diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 1481db4dcf..2ce996a0f5 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -160,6 +160,8 @@ btbuildempty(Relation index)
 	metapage = (Page) palloc(BLCKSZ);
 	_bt_initmetapage(metapage, P_NONE, 0, _bt_allequalimage(index, false));
 
+	nbt_opt_specialize(index);
+
 	/*
 	 * Write the page and log it.  It might seem that an immediate sync would
 	 * be sufficient to guarantee that the file exists on disk, but recovery
@@ -322,6 +324,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -764,6 +768,7 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 {
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
+	nbt_opt_specialize(info->index);
 
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
@@ -797,6 +802,8 @@ btvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
 	if (info->analyze_only)
 		return stats;
 
+	nbt_opt_specialize(info->index);
+
 	/*
 	 * If btbulkdelete was called, we need not do anything (we just maintain
 	 * the information used within _bt_vacuum_needs_cleanup() by calling
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index e81eee9c35..d5152bfcb7 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -181,6 +181,8 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
+	nbt_opt_specialize(scan->indexRelation);
+
 	pgstat_count_index_scan(rel);
 
 	/*
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 3558b2d3da..521a2a33c5 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -305,6 +305,8 @@ btbuild(Relation heap, Relation index, IndexInfo *indexInfo)
 	BTBuildState buildstate;
 	double		reltuples;
 
+	nbt_opt_specialize(index);
+
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
 		ResetUsage();
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 83e0dbab16..489b623663 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1132,6 +1132,19 @@ typedef struct BTOptions
 
 #ifdef NBTS_ENABLED
 
+/*
+ * Replace the functions in the rd_indam struct with a variant optimized for
+ * our key shape, if not already done.
+ *
+ * It only needs to be done once for every index relation loaded, so it's
+ * quite unlikely we need to do this and thus marked unlikely().
+ */
+#define nbt_opt_specialize(rel) \
+do { \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert)) \
+		_bt_specialize(rel); \
+} while (false)
+
 /*
  * Access a specialized nbtree function, based on the shape of the index key.
  */
@@ -1143,6 +1156,7 @@ typedef struct BTOptions
 
 #else /* not defined NBTS_ENABLED */
 
+#define nbt_opt_specialize(rel)
 #define NBT_SPECIALIZE_CALL(function, rel, ...) function(__VA_ARGS__)
 
 #endif /* NBTS_ENABLED */
-- 
2.30.2

From 825488ac1433612e4cbedc2479c7f0a8e1af295e Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Sun, 30 Jan 2022 16:23:31 +0100
Subject: [PATCH v6 1/8] Specialize nbtree functions on btree key shape

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, initially splitting splitting out
(not yet: specializing) the attcacheoff-capable case.

Note that we generate N specialized functions and 1 'default' function for each
specializable function.

This feature can be disabled by removing the #define NBTS_ENABLED -line in nbtree.h
---
 src/backend/access/nbtree/README           |  22 +
 src/backend/access/nbtree/nbtdedup.c       | 300 +------
 src/backend/access/nbtree/nbtdedup_spec.h  | 313 +++++++
 src/backend/access/nbtree/nbtinsert.c      | 572 +-----------
 src/backend/access/nbtree/nbtinsert_spec.h | 569 ++++++++++++
 src/backend/access/nbtree/nbtpage.c        |   4 +-
 src/backend/access/nbtree/nbtree.c         |  31 +-
 src/backend/access/nbtree/nbtree_spec.h    |  50 ++
 src/backend/access/nbtree/nbtsearch.c      | 994 +--------------------
 src/backend/access/nbtree/nbtsearch_spec.h | 994 +++++++++++++++++++++
 src/backend/access/nbtree/nbtsort.c        | 271 +-----
 src/backend/access/nbtree/nbtsort_spec.h   | 275 ++++++
 src/backend/access/nbtree/nbtsplitloc.c    |  14 +-
 src/backend/access/nbtree/nbtutils.c       | 755 +---------------
 src/backend/access/nbtree/nbtutils_spec.h  | 772 ++++++++++++++++
 src/include/access/nbtree.h                |  61 +-
 src/include/access/nbtree_specialize.h     | 204 +++++
 src/include/access/nbtree_specialized.h    |  67 ++
 18 files changed, 3355 insertions(+), 2913 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.h
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.h
 create mode 100644 src/backend/access/nbtree/nbtree_spec.h
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.h
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.h
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.h
 create mode 100644 src/include/access/nbtree_specialize.h
 create mode 100644 src/include/access/nbtree_specialized.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 5529afc1fe..3c08888c23 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1041,6 +1041,28 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+
+Notes about nbtree call specialization
+--------------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes.
+We can avoid it by specializing performance-sensitive search functions
+and calling those selectively.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.  This performance benefit is at the cost
+of binary size, so this feature can be disabled by defining NBTS_DISABLED.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - single-column indexes
+   NB: The code paths of this optimization do not support multiple key columns.
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also used for the default case, and is slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 0207421a5d..d7025d8e1c 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,259 +22,16 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
-			   Size newitemsz, bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple, and actually update the page.  Else
-			 * reset the state and move on without modifying the page.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
 
 /*
  * Perform bottom-up index deletion pass.
@@ -373,7 +130,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 			/* itup starts first pending interval */
 			_bt_dedup_start_pending(state, itup, offnum);
 		}
-		else if (_bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+		else if (nbts_call(_bt_keep_natts_fast, rel, state->base, itup) > nkeyatts &&
 				 _bt_dedup_save_htid(state, itup))
 		{
 			/* Tuple is equal; just added its TIDs to pending interval */
@@ -748,55 +505,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.h b/src/backend/access/nbtree/nbtdedup_spec.h
new file mode 100644
index 0000000000..27e5a7e686
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.h
@@ -0,0 +1,313 @@
+/*
+ * Specialized functions included in nbtdedup.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static bool NBTS_FUNCTION(_bt_do_singleval)(Relation rel, Page page, BTDedupState state,
+											OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+NBTS_FUNCTION(_bt_do_singleval)(Relation rel, Page page, BTDedupState state,
+								OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (nbts_call(_bt_keep_natts_fast, rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (nbts_call(_bt_keep_natts_fast, rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
+
+#endif /* ifndef NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+NBTS_FUNCTION(_bt_dedup_pass)(Relation rel, Buffer buf, Relation heapRel,
+							  IndexTuple newitem, Size newitemsz,
+							  bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				 minoff,
+				 maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = nbts_call(_bt_do_singleval, rel, page, state,
+								   minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 nbts_call(_bt_keep_natts_fast, rel, state->base, itup) > nkeyatts &&
+						   _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple, and actually update the page.  Else
+			 * reset the state and move on without modifying the page.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index f6f4af8bfe..ec6c73d1cc 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,18 +30,13 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
-static void _bt_stepright(Relation rel, BTInsertState insertstate, BTStack stack);
+static void _bt_stepright(Relation rel,
+										 BTInsertState insertstate,
+										 BTStack stack);
 static void _bt_insertonpg(Relation rel, BTScanInsert itup_key,
 						   Buffer buf,
 						   Buffer cbuf,
@@ -73,311 +68,10 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
-					   itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
-					  NULL);
-}
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -438,7 +132,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = nbts_call(_bt_binsrch_insert, rel, insertstate);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -483,7 +177,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset) < 0);
 				break;
 			}
 
@@ -508,7 +202,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (nbts_call(_bt_compare, rel, itup_key, page, offset) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -722,7 +416,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -769,246 +463,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
-					break;
-
-				_bt_stepright(rel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1649,7 +1103,7 @@ _bt_split(Relation rel, BTScanInsert itup_key, Buffer buf, Buffer cbuf,
 				lastleft = nposting;
 		}
 
-		lefthighkey = _bt_truncate(rel, lastleft, firstright, itup_key);
+		lefthighkey = nbts_call(_bt_truncate, rel, lastleft, firstright, itup_key);
 		itemsz = IndexTupleSize(lefthighkey);
 	}
 	else
@@ -2764,8 +2218,8 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 
 	/* Perform deduplication pass (when enabled and index-is-allequalimage) */
 	if (BTGetDeduplicateItems(rel) && itup_key->allequalimage)
-		_bt_dedup_pass(rel, buffer, heapRel, insertstate->itup,
-					   insertstate->itemsz, (indexUnchanged || uniquedup));
+		nbts_call(_bt_dedup_pass, rel, buffer, heapRel, insertstate->itup,
+				  insertstate->itemsz, (indexUnchanged || uniquedup));
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtinsert_spec.h b/src/backend/access/nbtree/nbtinsert_spec.h
new file mode 100644
index 0000000000..97c866aea3
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.h
@@ -0,0 +1,569 @@
+/*
+ * Specialized functions for nbtinsert.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static BTStack NBTS_FUNCTION(_bt_search_insert)(Relation rel,
+												BTInsertState insertstate);
+
+static OffsetNumber NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
+													 BTInsertState insertstate,
+													 bool checkingunique,
+													 bool indexUnchanged,
+													 BTStack stack,
+													 Relation heapRel);
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				nbts_call(_bt_compare, rel, insertstate->itup_key, page, P_HIKEY) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return nbts_call(_bt_search, rel, insertstate->itup_key,
+					 &insertstate->buf, BT_WRITE, NULL);
+}
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
+								 BTInsertState insertstate,
+								 bool checkingunique,
+								 bool indexUnchanged,
+								 BTStack stack,
+								 Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0)
+					break;
+
+				_bt_stepright(rel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	Assert(P_RIGHTMOST(opaque) ||
+		   nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0);
+
+	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
+
+#endif /* ifndef NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+NBTS_FUNCTION(_bt_doinsert)(Relation rel, IndexTuple itup,
+							IndexUniqueCheck checkUnique,
+							bool indexUnchanged,
+							Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = nbts_call(_bt_mkscankey, rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = nbts_call(_bt_search_insert, rel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = nbts_call(_bt_findinsertloc, rel, &insertstate, checkingunique,
+							   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
+					   itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 8b96708b3e..70304c793d 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1967,10 +1967,10 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 				}
 
 				/* we need an insertion scan key for the search, so build one */
-				itup_key = _bt_mkscankey(rel, targetkey);
+				itup_key = nbts_call(_bt_mkscankey, rel, targetkey);
 				/* find the leftmost leaf page with matching pivot/high key */
 				itup_key->pivotsearch = true;
-				stack = _bt_search(rel, itup_key, &sleafbuf, BT_READ, NULL);
+				stack = nbts_call(_bt_search, rel, itup_key, &sleafbuf, BT_READ, NULL);
 				/* won't need a second lock or pin on leafbuf */
 				_bt_relbuf(rel, sleafbuf);
 
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index b52eca8f38..1481db4dcf 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,10 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -177,33 +181,6 @@ btbuildempty(Relation index)
 	smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
diff --git a/src/backend/access/nbtree/nbtree_spec.h b/src/backend/access/nbtree/nbtree_spec.h
new file mode 100644
index 0000000000..4c342287f6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.h
@@ -0,0 +1,50 @@
+/*
+ * Specialized functions for nbtree.c
+ */
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+NBTS_FUNCTION(_bt_specialize)(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	nbts_call_norel(_bt_specialize, rel, rel);
+#else
+	rel->rd_indam->aminsert = NBTS_FUNCTION(btinsert);
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+NBTS_FUNCTION(btinsert)(Relation rel, Datum *values, bool *isnull,
+						ItemPointer ht_ctid, Relation heapRel,
+						IndexUniqueCheck checkUnique,
+						bool indexUnchanged,
+						IndexInfo *indexInfo)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	nbts_call_norel(_bt_specialize, rel, rel);
+
+	return nbts_call(btinsert, rel, values, isnull, ht_ctid, heapRel,
+					 checkUnique, indexUnchanged, indexInfo);
+#else
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = nbts_call(_bt_doinsert, rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+#endif
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index c74543bfde..e81eee9c35 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,11 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -46,6 +43,9 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -70,493 +70,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- */
-BTStack
-_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
-		   Snapshot snapshot)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split
- * is completed.  'stack' is only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  Snapshot snapshot)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		page = BufferGetPage(buf);
-		TestForOldSnapshot(snapshot, rel, page);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-			break;
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
-		{
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-			break;
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-			high = mid;
-	}
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-		{
-			high = mid;
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
 
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
@@ -625,217 +138,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-			return result;
-
-		scankey++;
-	}
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -1363,7 +665,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	 * Use the manufactured insertion scan key to descend the tree and
 	 * position ourselves on the target leaf page.
 	 */
-	stack = _bt_search(rel, &inskey, &buf, BT_READ, scan->xs_snapshot);
+	stack = nbts_call(_bt_search, rel, &inskey, &buf, BT_READ, scan->xs_snapshot);
 
 	/* don't need to keep the stack around... */
 	_bt_freestack(stack);
@@ -1392,7 +694,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
@@ -1422,9 +724,9 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	/*
 	 * Now load data from the first page of the scan.
 	 */
-	if (!_bt_readpage(scan, dir, offnum))
+	if (!nbts_call_norel(_bt_readpage, scan->indexRelation, scan, dir, offnum))
 	{
-		/*
+		/*`
 		 * There's no actually-matching data on this page.  Try to advance to
 		 * the next page.  Return false if there's no matching data at all.
 		 */
@@ -1498,280 +800,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2014,7 +1042,8 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 				PredicateLockPage(rel, blkno, scan->xs_snapshot);
 				/* see if there are any matches on this page */
 				/* note that this will clear moreRight if we can stop */
-				if (_bt_readpage(scan, dir, P_FIRSTDATAKEY(opaque)))
+				if (nbts_call_norel(_bt_readpage, scan->indexRelation,
+										scan, dir, P_FIRSTDATAKEY(opaque)))
 					break;
 			}
 			else if (scan->parallel_scan != NULL)
@@ -2116,7 +1145,8 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 				PredicateLockPage(rel, BufferGetBlockNumber(so->currPos.buf), scan->xs_snapshot);
 				/* see if there are any matches on this page */
 				/* note that this will clear moreLeft if we can stop */
-				if (_bt_readpage(scan, dir, PageGetMaxOffsetNumber(page)))
+				if (nbts_call_norel(_bt_readpage, scan->indexRelation, scan,
+										dir, PageGetMaxOffsetNumber(page)))
 					break;
 			}
 			else if (scan->parallel_scan != NULL)
@@ -2448,7 +1478,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	/*
 	 * Now load data from the first page of the scan.
 	 */
-	if (!_bt_readpage(scan, dir, start))
+	if (!nbts_call_norel(_bt_readpage, scan->indexRelation, scan, dir, start))
 	{
 		/*
 		 * There's no actually-matching data on this page.  Try to advance to
diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
new file mode 100644
index 0000000000..73d5370496
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -0,0 +1,994 @@
+/*
+ * Specialized functions for nbtsearch.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel, BTScanInsert key,
+											   Buffer buf);
+static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
+										OffsetNumber offnum);
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+NBTS_FUNCTION(_bt_binsrch)(Relation rel,
+						   BTScanInsert key,
+						   Buffer buf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = nbts_call(_bt_compare, rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+			high = mid;
+	}
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
+							OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (nbts_call(_bt_checkkeys, scan->indexRelation, scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			nbts_call(_bt_checkkeys, scan->indexRelation, scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = nbts_call(_bt_checkkeys, scan->indexRelation,
+									 scan, itup, indnatts, dir,
+									 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
+
+#endif /* NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ */
+BTStack
+NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
+						  int access, Snapshot snapshot)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = nbts_call(_bt_moveright, rel, key, *bufP,
+						  (access == BT_WRITE), stack_in,
+						  page_access, snapshot);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = nbts_call(_bt_binsrch, rel, key, *bufP);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = nbts_call(_bt_moveright, rel, key, *bufP, true, stack_in,
+						  BT_WRITE, snapshot);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split
+ * is completed.  'stack' is only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ */
+Buffer
+NBTS_FUNCTION(_bt_moveright)(Relation rel,
+							 BTScanInsert key,
+							 Buffer buf,
+							 bool forupdate,
+							 BTStack stack,
+							 int access,
+							 Snapshot snapshot)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		page = BufferGetPage(buf);
+		TestForOldSnapshot(snapshot, rel, page);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+			break;
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY) >= cmpval)
+		{
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+			break;
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = nbts_call(_bt_compare, rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+		{
+			high = mid;
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+NBTS_FUNCTION(_bt_compare)(Relation rel,
+						   BTScanInsert key,
+						   Page page,
+						   OffsetNumber offnum)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+	scankey = key->scankeys;
+	for (int i = 1; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+			return result;
+
+		scankey++;
+	}
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index bd1685c441..3558b2d3da 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,9 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
 /*
  *	btbuild() -- build a new btree index.
@@ -566,7 +567,7 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 
 	wstate.heap = btspool->heap;
 	wstate.index = btspool->index;
-	wstate.inskey = _bt_mkscankey(wstate.index, NULL);
+	wstate.inskey = nbts_call(_bt_mkscankey, wstate.index, NULL);
 	/* _bt_mkscankey() won't set allequalimage without metapage */
 	wstate.inskey->allequalimage = _bt_allequalimage(wstate.index, true);
 	wstate.btws_use_wal = RelationNeedsWAL(wstate.index);
@@ -578,7 +579,7 @@ _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE,
 								 PROGRESS_BTREE_PHASE_LEAF_LOAD);
-	_bt_load(&wstate, btspool, btspool2);
+	nbts_call_norel(_bt_load, wstate.index, &wstate, btspool, btspool2);
 }
 
 /*
@@ -978,8 +979,8 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 			lastleft = (IndexTuple) PageGetItem(opage, ii);
 
 			Assert(IndexTupleSize(oitup) > last_truncextra);
-			truncated = _bt_truncate(wstate->index, lastleft, oitup,
-									 wstate->inskey);
+			truncated = nbts_call(_bt_truncate, wstate->index, lastleft, oitup,
+								  wstate->inskey);
 			if (!PageIndexTupleOverwrite(opage, P_HIKEY, (Item) truncated,
 										 IndexTupleSize(truncated)))
 				elog(ERROR, "failed to add high key to the index page");
@@ -1176,264 +1177,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			AssertState(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.h b/src/backend/access/nbtree/nbtsort_spec.h
new file mode 100644
index 0000000000..8f4a3602ca
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.h
@@ -0,0 +1,275 @@
+/*
+ * Specialized functions included in nbtsort.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static void NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
+									BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
+						BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			AssertState(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (nbts_call(_bt_keep_natts_fast, wstate->index, dstate->base,
+							   itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
+
+#endif
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index 241e26d338..8e5337cad7 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -692,7 +692,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	{
 		itemid = PageGetItemId(state->origpage, maxoff);
 		tup = (IndexTuple) PageGetItem(state->origpage, itemid);
-		keepnatts = _bt_keep_natts_fast(state->rel, tup, state->newitem);
+		keepnatts = nbts_call(_bt_keep_natts_fast, state->rel, tup, state->newitem);
 
 		if (keepnatts > 1 && keepnatts <= nkeyatts)
 		{
@@ -723,7 +723,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 		!_bt_adjacenthtid(&tup->t_tid, &state->newitem->t_tid))
 		return false;
 	/* Check same conditions as rightmost item case, too */
-	keepnatts = _bt_keep_natts_fast(state->rel, tup, state->newitem);
+	keepnatts = nbts_call(_bt_keep_natts_fast, state->rel, tup, state->newitem);
 
 	if (keepnatts > 1 && keepnatts <= nkeyatts)
 	{
@@ -972,7 +972,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 	 * avoid appending a heap TID in new high key, we're done.  Finish split
 	 * with default strategy and initial split interval.
 	 */
-	perfectpenalty = _bt_keep_natts_fast(state->rel, leftmost, rightmost);
+	perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, leftmost, rightmost);
 	if (perfectpenalty <= indnkeyatts)
 		return perfectpenalty;
 
@@ -993,7 +993,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 	 * If page is entirely full of duplicates, a single value strategy split
 	 * will be performed.
 	 */
-	perfectpenalty = _bt_keep_natts_fast(state->rel, leftmost, rightmost);
+	perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, leftmost, rightmost);
 	if (perfectpenalty <= indnkeyatts)
 	{
 		*strategy = SPLIT_MANY_DUPLICATES;
@@ -1031,8 +1031,8 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 
 		itemid = PageGetItemId(state->origpage, P_HIKEY);
 		hikey = (IndexTuple) PageGetItem(state->origpage, itemid);
-		perfectpenalty = _bt_keep_natts_fast(state->rel, hikey,
-											 state->newitem);
+		perfectpenalty = nbts_call(_bt_keep_natts_fast, state->rel, hikey,
+								   state->newitem);
 		if (perfectpenalty <= indnkeyatts)
 			*strategy = SPLIT_SINGLE_VALUE;
 		else
@@ -1154,7 +1154,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 	lastleft = _bt_split_lastleft(state, split);
 	firstright = _bt_split_firstright(state, split);
 
-	return _bt_keep_natts_fast(state->rel, lastleft, firstright);
+	return nbts_call(_bt_keep_natts_fast, state->rel, lastleft, firstright);
 }
 
 /*
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index ff260c393a..bc443ebd27 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,11 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1221,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1704,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
new file mode 100644
index 0000000000..a4b934ae7a
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.h
@@ -0,0 +1,772 @@
+/*
+ * Specialized functions included in nbtutils.c
+ */
+
+/*
+ * These functions are not exposed, so their "default" emitted form would be
+ * unused and would generate warnings. Avoid unused code generation and the
+ * subsequent warnings by not emitting these functions when generating the
+ * code for defaults.
+ */
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static bool NBTS_FUNCTION(_bt_check_rowcompare)(ScanKey skey,
+												IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+												ScanDirection dir, bool *continuescan);
+
+static int	NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
+										  IndexTuple firstright, BTScanInsert itup_key);
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+NBTS_FUNCTION(_bt_check_rowcompare)(ScanKey skey, IndexTuple tuple,
+									int tupnatts, TupleDesc tupdesc,
+									ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
+							  IndexTuple firstright, BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == nbts_call(_bt_keep_natts_fast, rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+#endif /* NBTS_SPECIALIZING_DEFAULT */
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+NBTS_FUNCTION(_bt_checkkeys)(Relation rel, IndexScanDesc scan,
+							 IndexTuple tuple, int tupnatts,
+							 ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (nbts_call_norel(_bt_check_rowcompare, rel, key, tuple,
+								tupnatts, tupdesc, dir, continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+NBTS_FUNCTION(_bt_truncate)(Relation rel, IndexTuple lastleft,
+							IndexTuple firstright, BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = nbts_call(_bt_keep_natts, rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel,
+								   IndexTuple lastleft,
+								   IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 93f8267b48..83e0dbab16 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1116,15 +1116,47 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+
+
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define NBTS_ENABLED
+
+#ifdef NBTS_ENABLED
+
+/*
+ * Access a specialized nbtree function, based on the shape of the index key.
+ */
+
+#define NBT_SPECIALIZE_CALL(function, rel, ...) \
+( \
+	NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+)
+
+#else /* not defined NBTS_ENABLED */
+
+#define NBT_SPECIALIZE_CALL(function, rel, ...) function(__VA_ARGS__)
+
+#endif /* NBTS_ENABLED */
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specialized.h"
+#include "nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1155,9 +1187,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
-						   IndexTuple newitem, Size newitemsz,
-						   bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1173,9 +1202,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Buffer lbuf, BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, BTStack stack, BlockNumber child);
 
@@ -1223,12 +1249,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
-						  int access, Snapshot snapshot);
-extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
@@ -1237,7 +1257,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1245,8 +1264,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1259,10 +1276,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
new file mode 100644
index 0000000000..23fdda4f0e
--- /dev/null
+++ b/src/include/access/nbtree_specialize.h
@@ -0,0 +1,204 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_call(function, indexrel, ...rest_of_args), and
+ *   nbts_call_norel(function, indexrel, ...args)
+ *     This will call the specialized variant of 'function' based on the index
+ *     relation data.
+ *     The difference between nbts_call and nbts_call_norel is that _call
+ *     uses indexrel as first argument in the function call, whereas
+ *     nbts_call_norel does not.
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ *
+ * example usage:
+ *
+ * kwithnulls = nbts_call_norel(_bt_key_hasnulls, myindex, mytuple, tupDesc);
+ *
+ * NBTS_FUNCTION(_bt_key_hasnulls)(IndexTuple mytuple, TupleDesc tupDesc)
+ * {
+ *    nbts_attiterdeclare(mytuple);
+ *    nbts_attiterinit(mytuple, 1, tupDesc);
+ *    nbts_foreachattr(1, 10)
+ *    {
+ *        Datum it = nbts_attiter_nextattdatum(tuple, tupDesc);
+ *        if (nbts_attiter_curattisnull(tuple))
+ *           return true;
+ *    }
+ *    return false
+ * }
+ */
+
+/*
+ * Call a potentially specialized function for a given btree operation.
+ *
+ * NB: the rel argument is evaluated multiple times.
+ */
+#define nbts_call(name, rel, ...) \
+	nbts_call_norel(name, (rel), (rel), __VA_ARGS__)
+
+#ifdef NBTS_ENABLED
+
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+#ifdef nbts_call_norel
+#undef nbts_call_norel
+#endif
+
+#define nbts_call_norel(name, rel, ...) \
+	(NBTS_FUNCTION(name)(__VA_ARGS__))
+
+/*
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_CACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/* reset call to SPECIALIZE_CALL for default behaviour */
+#undef nbts_call_norel
+#define nbts_call_norel(name, rel, ...) \
+	NBT_SPECIALIZE_CALL(name, (rel), __VA_ARGS__)
+
+/*
+ * "Default", externally accessible, not so much optimized functions
+ */
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+/* for the default functions, we want to use the unspecialized name. */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) name
+
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/* from here on there are no more NBTS_FUNCTIONs */
+#undef NBTS_FUNCTION
+
+#else /* not defined NBTS_ENABLED */
+
+/*
+ * NBTS_ENABLE is not defined, so we don't want to use the specializations.
+ * We revert to the behaviour from PG14 and earlier, which only uses
+ * attcacheoff.
+ */
+
+#define NBTS_FUNCTION(name) name
+
+#define nbts_call_norel(name, rel, ...) \
+	name(__VA_ARGS__)
+
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+
+#endif /* !NBTS_ENABLED */
diff --git a/src/include/access/nbtree_specialized.h b/src/include/access/nbtree_specialized.h
new file mode 100644
index 0000000000..c45fa84aed
--- /dev/null
+++ b/src/include/access/nbtree_specialized.h
@@ -0,0 +1,67 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void
+NBTS_FUNCTION(_bt_specialize)(Relation rel);
+
+extern bool
+NBTS_FUNCTION(btinsert)(Relation rel, Datum *values, bool *isnull,
+						ItemPointer ht_ctid, Relation heapRel,
+						IndexUniqueCheck checkUnique,
+						bool indexUnchanged,
+						struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void
+NBTS_FUNCTION(_bt_dedup_pass)(Relation rel, Buffer buf, Relation heapRel,
+							  IndexTuple newitem, Size newitemsz,
+							  bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool
+NBTS_FUNCTION(_bt_doinsert)(Relation rel, IndexTuple itup,
+							IndexUniqueCheck checkUnique, bool indexUnchanged,
+							Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack
+NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key,
+						  Buffer *bufP, int access,
+						  Snapshot snapshot);
+extern Buffer
+NBTS_FUNCTION(_bt_moveright)(Relation rel, BTScanInsert key, Buffer buf,
+							 bool forupdate, BTStack stack, int access,
+							 Snapshot snapshot);
+extern OffsetNumber
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate);
+extern int32
+NBTS_FUNCTION(_bt_compare)(Relation rel, BTScanInsert key,
+						   Page page, OffsetNumber offnum);
+
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert
+NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup);
+extern bool
+NBTS_FUNCTION(_bt_checkkeys)(Relation rel, IndexScanDesc scan,
+							 IndexTuple tuple, int tupnatts,
+							 ScanDirection dir, bool *continuescan);
+extern IndexTuple
+NBTS_FUNCTION(_bt_truncate)(Relation rel, IndexTuple lastleft,
+							IndexTuple firstright, BTScanInsert itup_key);
+extern int
+NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel, IndexTuple lastleft,
+								   IndexTuple firstright);
-- 
2.30.2

From 1ea75d187f602bed86a9bce88f2c50c1faeba49c Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 7 Apr 2022 12:30:00 +0200
Subject: [PATCH v6 2/8] Use specialized attribute iterators in
 backend/*/nbt*_spec.h

Split out for making it clear what substantial changes were made to the
pre-existing functions.

Even though not all nbt*_spec functions have been updated; most call sites
now can directly call the specialized functions instead of having to determine
the right specialization based on the (potentially locally unavailable) index
relation, making the specialization of those functions worth the effort.
---
 src/backend/access/nbtree/nbtsearch_spec.h | 16 +++---
 src/backend/access/nbtree/nbtsort_spec.h   | 24 +++++----
 src/backend/access/nbtree/nbtutils_spec.h  | 63 +++++++++++++---------
 3 files changed, 62 insertions(+), 41 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
index 73d5370496..a5c5f2b94f 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.h
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -823,6 +823,7 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -854,23 +855,26 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
diff --git a/src/backend/access/nbtree/nbtsort_spec.h b/src/backend/access/nbtree/nbtsort_spec.h
index 8f4a3602ca..d3f2db2dc4 100644
--- a/src/backend/access/nbtree/nbtsort_spec.h
+++ b/src/backend/access/nbtree/nbtsort_spec.h
@@ -27,8 +27,7 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -50,7 +49,7 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -82,22 +81,25 @@ NBTS_FUNCTION(_bt_load)(BTWriteState *wstate, BTSpool *btspool,
 			}
 			else if (itup != NULL)
 			{
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 				int32		compare = 0;
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.h b/src/backend/access/nbtree/nbtutils_spec.h
index a4b934ae7a..638eff18f6 100644
--- a/src/backend/access/nbtree/nbtutils_spec.h
+++ b/src/backend/access/nbtree/nbtutils_spec.h
@@ -211,6 +211,8 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -222,20 +224,22 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -243,6 +247,7 @@ NBTS_FUNCTION(_bt_keep_natts)(Relation rel, IndexTuple lastleft,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -295,7 +300,7 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -326,7 +331,10 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -337,27 +345,30 @@ NBTS_FUNCTION(_bt_mkscankey)(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -744,24 +755,28 @@ NBTS_FUNCTION(_bt_keep_natts_fast)(Relation rel,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft,itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) !=
+			nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
-- 
2.30.2

From 8d587233c593d510edc50783af303831837f6b32 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 21 Apr 2022 16:22:07 +0200
Subject: [PATCH v6 7/8] Add specialization to btree index creation.

This was an oversight that is corrected easily; but an oversight nonetheless.
This increases the (re)build performance of indexes by another few percents.
---
 src/backend/utils/sort/multisort.c            |  22 +++
 src/backend/utils/sort/tuplesortvariants.c    | 146 +----------------
 .../utils/sort/tuplesortvariants_nbts.h       | 150 ++++++++++++++++++
 src/include/access/nbtree.h                   |  18 +++
 4 files changed, 196 insertions(+), 140 deletions(-)
 create mode 100644 src/backend/utils/sort/multisort.c
 create mode 100644 src/backend/utils/sort/tuplesortvariants_nbts.h

diff --git a/src/backend/utils/sort/multisort.c b/src/backend/utils/sort/multisort.c
new file mode 100644
index 0000000000..3c0871faa6
--- /dev/null
+++ b/src/backend/utils/sort/multisort.c
@@ -0,0 +1,22 @@
+#include "postgres.h"
+
+#include "utils/sortsupport.h"
+#include "utils/tuplesort.h"
+
+struct MultiSortData {
+	Tuplesortstate *buffer;
+	void *inner;
+	
+};
+
+
+/*
+ *	MultiSort {
+ *		TupleSort buffer		Contains sorted run of tuples received from
+ *								innerstate. May have dropped tuples since.
+ *		void* innerstate		Inner state of multisort scheme.
+ *		SortSlot low_watermark	all tuples up to X have been received)
+ *		SortSlot high_watermark (no tuples after X have been received)
+ *	}
+ * sort_begin(MultiSort state, 
+ */
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index 2933020dcc..06fdeb64c6 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -57,8 +57,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int len);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static void writetup_index(Tuplesortstate *state, LogicalTape *tape,
@@ -130,6 +128,10 @@ typedef struct
 	int			datumTypeLen;
 } TuplesortDatumArg;
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesortvariants_nbts.h"
+#include "access/nbtree_specialize.h"
+#undef NBT_SPECIALIZE_FILE
+
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
 					 int nkeys, AttrNumber *attNums,
@@ -350,7 +352,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 								PARALLEL_SORT(coordinate));
 
 	base->removeabbrev = removeabbrev_index;
-	base->comparetup = comparetup_index_btree;
+	base->comparetup = NBT_SPECIALIZE_NAME(comparetup_index_btree, indexRel);
 	base->writetup = writetup_index;
 	base->readtup = readtup_index;
 	base->haveDatum1 = true;
@@ -475,7 +477,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 	base->nKeys = IndexRelationGetNumberOfKeyAttributes(indexRel);
 
 	base->removeabbrev = removeabbrev_index;
-	base->comparetup = comparetup_index_btree;
+	base->comparetup = NBT_SPECIALIZE_NAME(comparetup_index_btree, indexRel);
 	base->writetup = writetup_index;
 	base->readtup = readtup_index;
 	base->haveDatum1 = true;
@@ -1245,142 +1247,6 @@ removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
 	}
 }
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
-	SortSupport sortKey = base->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = base->nKeys;
-	tupDes = RelationGetDescr(arg->index.indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(arg->index.indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(arg->index.heapRel,
-									RelationGetRelationName(arg->index.indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesortvariants_nbts.h b/src/backend/utils/sort/tuplesortvariants_nbts.h
new file mode 100644
index 0000000000..d52d34c749
--- /dev/null
+++ b/src/backend/utils/sort/tuplesortvariants_nbts.h
@@ -0,0 +1,150 @@
+#ifndef NBTS_SPECIALIZING_DEFAULT
+
+static int NBTS_FUNCTION(comparetup_index_btree)(const SortTuple *a,
+												 const SortTuple *b,
+												 Tuplesortstate *state);
+
+static int
+NBTS_FUNCTION(comparetup_index_btree)(const SortTuple *a, const SortTuple *b,
+									  Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
+	SortSupport sortKey = base->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = base->nKeys;
+	tupDes = RelationGetDescr(arg->index.indexRel);
+
+	if (!sortKey->abbrev_converter)
+	{
+		nkey = 2;
+		sortKey++;
+	}
+	else
+		nkey = 1;
+
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
+	{
+		Datum		datum1,
+					datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+		{
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		}
+		else
+		{
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
+		}
+
+		if (compare != 0)
+			return compare;
+
+		if (nbts_attiter_curattisnull(tuple1))
+			equal_hasnull = true;
+
+		sortKey++;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(arg->index.indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(arg->index.heapRel,
+									   RelationGetRelationName(arg->index.indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
+
+#endif
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 92894e4ea7..11116b47ca 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1170,6 +1170,24 @@ do { \
 	) \
 )
 
+#define NBT_SPECIALIZE_NAME(name, rel) \
+( \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_COLUMN) \
+	) \
+	: \
+	( \
+		TupleDescAttr(RelationGetDescr(rel), \
+					  IndexRelationGetNumberOfKeyAttributes(rel) - 1)->attcacheoff > 0 ? ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+		) \
+		: \
+		( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED) \
+		) \
+	) \
+)
+
 #else /* not defined NBTS_ENABLED */
 
 #define nbt_opt_specialize(rel)
-- 
2.30.2

From 81fd521dc4e67896456703997caddaa00721686f Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 8 Apr 2022 14:44:01 +0200
Subject: [PATCH v6 6/8] Implement specialized uncacheable attribute iteration

Uses an iterator to prevent doing duplicate work while iterating over
attributes.

Inspiration: https://www.postgresql.org/message-id/CAEze2WjE9ka8i%3Ds-Vv5oShro9xTrt5VQnQvFG9AaRwWpMm3-fg%40mail.gmail.com
---
 src/backend/access/nbtree/nbtree_spec.h |   1 +
 src/include/access/itup_attiter.h       | 198 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  13 +-
 src/include/access/nbtree_specialize.h  |  40 ++++-
 4 files changed, 249 insertions(+), 3 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/backend/access/nbtree/nbtree_spec.h b/src/backend/access/nbtree/nbtree_spec.h
index 4c342287f6..88b01c86f7 100644
--- a/src/backend/access/nbtree/nbtree_spec.h
+++ b/src/backend/access/nbtree/nbtree_spec.h
@@ -9,6 +9,7 @@ void
 NBTS_FUNCTION(_bt_specialize)(Relation rel)
 {
 #ifdef NBTS_SPECIALIZING_DEFAULT
+	PopulateTupleDescCacheOffsets(rel->rd_att);
 	nbts_call_norel(_bt_specialize, rel, rel);
 #else
 	rel->rd_indam->aminsert = NBTS_FUNCTION(btinsert);
diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..9f16a4b3d7
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,198 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 1559399b0e..92894e4ea7 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1122,6 +1123,7 @@ typedef struct BTOptions
  */
 #define NBTS_TYPE_SINGLE_COLUMN single
 #define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_DEFAULT default
 
 
@@ -1152,12 +1154,19 @@ do { \
 
 #define NBT_SPECIALIZE_CALL(function, rel, ...) \
 ( \
-	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? (   \
+	IndexRelationGetNumberOfKeyAttributes(rel) == 1 ? ( \
 		NBTS_MAKE_NAME(function, NBTS_TYPE_SINGLE_COLUMN)(__VA_ARGS__) \
 	) \
 	: \
 	( \
-		NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+		TupleDescAttr(RelationGetDescr(rel), \
+					  IndexRelationGetNumberOfKeyAttributes(rel) - 1)->attcacheoff > 0 ? ( \
+			NBTS_MAKE_NAME(function, NBTS_TYPE_CACHED)(__VA_ARGS__) \
+		) \
+		: \
+		( \
+			NBTS_MAKE_NAME(function, NBTS_TYPE_UNCACHED)(__VA_ARGS__) \
+		) \
 	) \
 )
 
diff --git a/src/include/access/nbtree_specialize.h b/src/include/access/nbtree_specialize.h
index 9733a27bdd..efbacf7d67 100644
--- a/src/include/access/nbtree_specialize.h
+++ b/src/include/access/nbtree_specialize.h
@@ -115,7 +115,11 @@
 #define nbts_attiter_nextattdatum(itup, tupDesc) \
 ( \
 	AssertMacro(spec_i == 0), \
-	(IndexTupleHasNulls(itup) && att_isnull(0, (char *)(itup) + sizeof(IndexTupleData))) ? \
+	( \
+		IndexTupleHasNulls(itup) && \
+		att_isnull(0, (bits8 *) ((char *) (itup) + sizeof(IndexTupleData))) \
+	) \
+	? \
 	( \
 		(NBTS_MAKE_NAME(itup, isNull)) = true, \
 		(Datum)NULL \
@@ -175,6 +179,40 @@
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /* reset call to SPECIALIZE_CALL for default behaviour */
 #undef nbts_call_norel
 #define nbts_call_norel(name, rel, ...) \
-- 
2.30.2

From 512c885a103a807eadf5c8611b66eeb6ca74b11d Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Mon, 6 Jun 2022 23:16:18 +0200
Subject: [PATCH v6 8/8] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also have those prefixing attributes that equal the
scankey.

We cannot propagate this information to _binsrch on lower pages,
as this downstream page may concurrently have split and/or have
merged with its deleted left neighbour (see [0]), which moves
the keyspace of the linked page. We thus can only trust the
current state of this current page for this optimization, which
means we must validate this state each time we open the page.

Although this limits the overall applicability of the
performance improvement, it still allows for a nice performance
improvement in most cases where initial columns have many
duplicate values and a compare function that is not cheap.

Additionally, most of the time a pages' highkey is equal to the
right seperator on the parent page. By storing this seperator
and doing a binary equality check, we can cheaply validate the
highkey on a page, which also allows us to carry over the
right seperators' prefix into the page.
---
 contrib/amcheck/verify_nbtree.c            |  17 +--
 src/backend/access/nbtree/README           |  25 +++++
 src/backend/access/nbtree/nbtinsert.c      |  14 ++-
 src/backend/access/nbtree/nbtinsert_spec.h |  22 ++--
 src/backend/access/nbtree/nbtsearch.c      |   3 +-
 src/backend/access/nbtree/nbtsearch_spec.h | 115 ++++++++++++++++++---
 src/include/access/nbtree_specialized.h    |   9 +-
 7 files changed, 169 insertions(+), 36 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 2beeebb163..8c4215372a 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2700,6 +2700,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2709,13 +2710,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2777,6 +2778,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2787,7 +2789,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2839,10 +2841,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2862,10 +2865,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2900,13 +2904,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 3c08888c23..13ac9ee2be 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,31 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+potentially saving cycles.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by an inner page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. (2,2) to (1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+The positive part of this, is that we already have results of the highest
+value of a page: a pages' highkey is compared to the scankey while we have
+a pin on the page in the _bt_moveright procedure. The _bt_binsrch procedure
+will use this result as a rightmost prefix compare, and for each step in the
+binary search (that does not compare less than the insert key) improve the
+equal-prefix bounds.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index ec6c73d1cc..20e5f33f98 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -132,7 +132,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = nbts_call(_bt_binsrch_insert, rel, insertstate);
+	offset = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -142,6 +142,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -177,7 +179,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset) < 0);
+				Assert(nbts_call(_bt_compare, rel, itup_key, page, offset,
+								 &cmpcol) < 0);
 				break;
 			}
 
@@ -202,7 +205,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (nbts_call(_bt_compare, rel, itup_key, page, offset) != 0)
+					if (nbts_call(_bt_compare, rel, itup_key, page, offset,
+								  &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -412,11 +416,13 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY);
+			highkeycmp = nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY,
+								   &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
diff --git a/src/backend/access/nbtree/nbtinsert_spec.h b/src/backend/access/nbtree/nbtinsert_spec.h
index 97c866aea3..ccba0fa5ed 100644
--- a/src/backend/access/nbtree/nbtinsert_spec.h
+++ b/src/backend/access/nbtree/nbtinsert_spec.h
@@ -73,6 +73,7 @@ NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	comparecol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -91,7 +92,8 @@ NBTS_FUNCTION(_bt_search_insert)(Relation rel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				nbts_call(_bt_compare, rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				nbts_call(_bt_compare, rel, insertstate->itup_key, page,
+						  P_HIKEY, &comparecol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -221,6 +223,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -238,7 +241,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0)
+					nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, insertstate, stack);
@@ -291,6 +294,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -321,7 +325,8 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) != 0 ||
+				nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY,
+						  &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -336,10 +341,13 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   nbts_call(_bt_compare, rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) || nbts_call(_bt_compare, rel, itup_key,
+												page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+	newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -358,7 +366,7 @@ NBTS_FUNCTION(_bt_findinsertloc)(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate);
+		newitemoff = nbts_call(_bt_binsrch_insert, rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index d5152bfcb7..607940bbcd 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -178,6 +178,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	AttrNumber	attno = 1;
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -696,7 +697,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf);
+	offnum = nbts_call(_bt_binsrch, rel, &inskey, buf, &attno);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/backend/access/nbtree/nbtsearch_spec.h b/src/backend/access/nbtree/nbtsearch_spec.h
index a5c5f2b94f..19a6178334 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.h
+++ b/src/backend/access/nbtree/nbtsearch_spec.h
@@ -10,8 +10,10 @@
  */
 #ifndef NBTS_SPECIALIZING_DEFAULT
 
-static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel, BTScanInsert key,
-											   Buffer buf);
+static OffsetNumber NBTS_FUNCTION(_bt_binsrch)(Relation rel,
+											   BTScanInsert key,
+											   Buffer buf,
+											   AttrNumber *highkeycmpcol);
 static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
 										OffsetNumber offnum);
 
@@ -38,7 +40,8 @@ static bool NBTS_FUNCTION(_bt_readpage)(IndexScanDesc scan, ScanDirection dir,
 static OffsetNumber
 NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 						   BTScanInsert key,
-						   Buffer buf)
+						   Buffer buf,
+						   AttrNumber *highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -46,6 +49,8 @@ NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -87,17 +92,26 @@ NBTS_FUNCTION(_bt_binsrch)(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = nbts_call(_bt_compare, rel, key, page, mid);
+		result = nbts_call(_bt_compare, rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
 
+	*highkeycmpcol = highcmpcol;
+
 	/*
 	 * At this point we have high == low, but be careful: they could point
 	 * past the last slot on the page.
@@ -423,6 +437,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
 
 	/* Get the root page to start with */
 	*bufP = _bt_getroot(rel, access);
@@ -441,6 +456,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		IndexTuple	itup;
 		BlockNumber child;
 		BTStack		new_stack;
+		AttrNumber	highkeycmpcol = 1;
 
 		/*
 		 * Race -- the page we just grabbed may have split since we read its
@@ -456,7 +472,8 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 */
 		*bufP = nbts_call(_bt_moveright, rel, key, *bufP,
 						  (access == BT_WRITE), stack_in,
-						  page_access, snapshot);
+						  page_access, snapshot, &highkeycmpcol,
+						  (char *) tupdatabuf);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -468,12 +485,17 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = nbts_call(_bt_binsrch, rel, key, *bufP);
+		offnum = nbts_call(_bt_binsrch, rel, key, *bufP, &highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		if (highkeycmpcol > 1)
+		{
+			memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+		}
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -507,6 +529,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		AttrNumber highkeycmpcol = 1;
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -517,7 +540,7 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key, Buffer *bufP,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = nbts_call(_bt_moveright, rel, key, *bufP, true, stack_in,
-						  BT_WRITE, snapshot);
+						  BT_WRITE, snapshot, &highkeycmpcol, (char *) tupdatabuf);
 	}
 
 	return stack_in;
@@ -565,12 +588,16 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 							 bool forupdate,
 							 BTStack stack,
 							 int access,
-							 Snapshot snapshot)
+							 Snapshot snapshot,
+							 AttrNumber *comparecol,
+							 char *tupdatabuf)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
+	Assert(PointerIsValid(comparecol));
+
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
 	 * this page is > the high key stored on the page, then the page has split
@@ -592,12 +619,17 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -623,14 +655,49 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY) >= cmpval)
+		/*
+		 * When comparecol is > 1, tupdatabuf is filled with the right seperator
+		 * of the parent node. This allows us to do a binary equality check
+		 * between the parent node's right seperator (which is < key) and this
+		 * page's P_HIKEY. If they equal, we can reuse the result of the
+		 * parent node's rightkey compare, which means we can potentially save
+		 * a full key compare.
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, with this optimization we can
+		 * skip one of those.
+		 * 
+		 * 3: 1 for the highkey (rightmost), and on average 2 before we move
+		 * right in the binary search on the page.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			}
+		}
+
+		if (P_IGNORE(opaque) || nbts_call(_bt_compare, rel, key, page, P_HIKEY,
+										  &cmpcol) >= cmpval)
 		{
 			/* step right one page */
+			*comparecol = 1;
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -663,7 +730,8 @@ NBTS_FUNCTION(_bt_moveright)(Relation rel,
  * list split).
  */
 OffsetNumber
-NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate,
+								  AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -673,6 +741,7 @@ NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -723,16 +792,21 @@ NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = nbts_call(_bt_compare, rel, key, page, mid);
+		result = nbts_call(_bt_compare, rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -813,7 +887,8 @@ int32
 NBTS_FUNCTION(_bt_compare)(Relation rel,
 						   BTScanInsert key,
 						   Page page,
-						   OffsetNumber offnum)
+						   OffsetNumber offnum,
+						   AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -854,10 +929,11 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	nbts_attiterinit(itup, 1, itupdesc);
 
-	nbts_foreachattr(1, ncmpkey)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+	scankey = key->scankeys + ((*comparecol) - 1);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
 
@@ -902,11 +978,20 @@ NBTS_FUNCTION(_bt_compare)(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = nbts_attiter_attnum;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
diff --git a/src/include/access/nbtree_specialized.h b/src/include/access/nbtree_specialized.h
index c45fa84aed..ddceb4a4aa 100644
--- a/src/include/access/nbtree_specialized.h
+++ b/src/include/access/nbtree_specialized.h
@@ -43,12 +43,15 @@ NBTS_FUNCTION(_bt_search)(Relation rel, BTScanInsert key,
 extern Buffer
 NBTS_FUNCTION(_bt_moveright)(Relation rel, BTScanInsert key, Buffer buf,
 							 bool forupdate, BTStack stack, int access,
-							 Snapshot snapshot);
+							 Snapshot snapshot, AttrNumber *comparecol,
+							 char *tupdatabuf);
 extern OffsetNumber
-NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate);
+NBTS_FUNCTION(_bt_binsrch_insert)(Relation rel, BTInsertState insertstate,
+								  AttrNumber highcmpcol);
 extern int32
 NBTS_FUNCTION(_bt_compare)(Relation rel, BTScanInsert key,
-						   Page page, OffsetNumber offnum);
+						   Page page, OffsetNumber offnum,
+						   AttrNumber *comparecol);
 
 /*
  * prototypes for functions in nbtutils_spec.h
-- 
2.30.2

From a3aad32e679d75ec98f05ea7fa24ebc6109d434e Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 16 Sep 2022 17:38:32 +0200
Subject: [PATCH v7] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also have those prefixing attributes that equal the
scankey.

We cannot generally propagate this information to _binsrch on
lower pages, as this downstream page may have concurrently split
and/or have merged with its deleted left neighbour (see [0]),
which moves the keyspace of the linked page. We thus can only
trust the current state of this current page for this optimization,
which means we must validate this state each time we open the page.

Although this limits the overall applicability of the
performance improvement, it still allows for a nice performance
improvement in most cases where initial columns have many
duplicate values and a compare function that is not cheap.

As an exception to the above rule, most of the time a pages'
highkey is equal to the right seperator on the parent page due to
how btree splits are done. By storing this right seperator from
the parent page and then validating that the highkey of the child
page contains the exact same data, we can restore the right prefix
bound without having to call the relatively expensive _bt_compare.

In the worst-case scenario of a concurrent page split, we'd still
have to validate the full key, but that doesn't happen very often,
so we pay one branch and memcmp() to validate whether .
---
 contrib/amcheck/verify_nbtree.c       |  17 ++--
 src/backend/access/nbtree/README      |  42 +++++++++
 src/backend/access/nbtree/nbtinsert.c |  34 +++++---
 src/backend/access/nbtree/nbtsearch.c | 119 +++++++++++++++++++++++---
 src/include/access/nbtree.h           |  10 ++-
 5 files changed, 188 insertions(+), 34 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 9021d156eb..041ff5464e 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2701,6 +2701,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2710,13 +2711,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2778,6 +2779,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2788,7 +2790,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2840,10 +2842,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2863,10 +2866,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2901,13 +2905,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 5529afc1fe..5df29a692e 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,48 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+saving the indirect function calls in the compare operation.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by a parent page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. [2,3) to [1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+There is positive news, though: A page split will put a binary copy of the
+page's highkey in the parent page. This means that we usually can reuse
+the compare result of the parent page's downlink's right sibling when we
+discover that their representation is binary equal. In general this will
+be the case, as only in concurrent page splits and deletes the downlink
+may not point to the page with the correct highkey bound (_bt_moveright
+only rarely actually moves right).
+
+To implement this, we copy the downlink's right differentiator key into a
+temporary buffer, which is then compared against the child pages' highkey.
+If they match, we reuse the compare result (plus prefix) we had for it from
+the parent page, if not, we need to do a full _bt_compare. Because memcpy +
+memcmp is cheap compared to _bt_compare, and because it's quite unlikely
+that we guess wrong this speeds up our _bt_moveright code (at cost of some
+stack memory in _bt_search and some overhead in case of a wrong prediction)
+
+Now that we have prefix bounds on the highest value of a page, the
+_bt_binsrch procedure will use this result as a rightmost prefix compare,
+and for each step in the binary search (that does not compare less than the
+insert key) improve the equal-prefix bounds.
+
+Using the above optimization, we now (on average) only need 2 full key
+compares per page, as opposed to ceil(log2(ntupsperpage)) + 1; a significant
+improvement.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index f6f4af8bfe..36e2d8ffed 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -326,6 +326,7 @@ _bt_search_insert(Relation rel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -344,7 +345,8 @@ _bt_search_insert(Relation rel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -438,7 +440,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = _bt_binsrch_insert(rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -448,6 +450,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -483,7 +487,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(_bt_compare(rel, itup_key, page, offset, &cmpcol) < 0);
 				break;
 			}
 
@@ -508,7 +512,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (_bt_compare(rel, itup_key, page, offset, &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -718,11 +722,12 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -865,6 +870,8 @@ _bt_findinsertloc(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
+
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -882,7 +889,7 @@ _bt_findinsertloc(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, insertstate, stack);
@@ -935,6 +942,8 @@ _bt_findinsertloc(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
+
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -965,7 +974,7 @@ _bt_findinsertloc(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -980,10 +989,13 @@ _bt_findinsertloc(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -1002,7 +1014,7 @@ _bt_findinsertloc(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index c74543bfde..67c8705c54 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,7 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
 static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
@@ -98,6 +99,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
 
 	/* Get the root page to start with */
 	*bufP = _bt_getroot(rel, access);
@@ -130,7 +133,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * opportunity to finish splits of internal pages too.
 		 */
 		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot);
+							  page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -142,12 +146,15 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -181,6 +188,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		highkeycmpcol = 1;
+
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -191,7 +200,7 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
 	}
 
 	return stack_in;
@@ -239,12 +248,16 @@ _bt_moveright(Relation rel,
 			  bool forupdate,
 			  BTStack stack,
 			  int access,
-			  Snapshot snapshot)
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
+
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
 	 * this page is > the high key stored on the page, then the page has split
@@ -266,12 +279,17 @@ _bt_moveright(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -297,14 +315,55 @@ _bt_moveright(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
 		{
+			*comparecol = 1;
 			/* step right one page */
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -337,7 +396,8 @@ _bt_moveright(Relation rel,
 static OffsetNumber
 _bt_binsrch(Relation rel,
 			BTScanInsert key,
-			Buffer buf)
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -345,6 +405,8 @@ _bt_binsrch(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -386,16 +448,25 @@ _bt_binsrch(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
+	
+	*highkeycmpcol = highcmpcol;
 
 	/*
 	 * At this point we have high == low, but be careful: they could point
@@ -439,7 +510,8 @@ _bt_binsrch(Relation rel,
  * list split).
  */
 OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -449,6 +521,7 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -499,16 +572,22 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
+
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -656,7 +735,8 @@ int32
 _bt_compare(Relation rel,
 			BTScanInsert key,
 			Page page,
-			OffsetNumber offnum)
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -696,8 +776,9 @@ _bt_compare(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
 	{
 		Datum		datum;
 		bool		isNull;
@@ -741,11 +822,20 @@ _bt_compare(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = i;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
@@ -876,6 +966,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	AttrNumber	cmpcol = 1;
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1392,7 +1483,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = _bt_binsrch(rel, &inskey, buf, &cmpcol);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 8e4f6864e5..ddc34a7a9e 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1225,9 +1225,13 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
 						  int access, Snapshot snapshot);
 extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
+							bool forupdate, BTStack stack, int access,
+							Snapshot snapshot, AttrNumber *comparecol,
+							char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
-- 
2.30.2

From 02ff7258fa073e9a21b032ea40da34620a265182 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Tue, 10 Jan 2023 21:45:44 +0100
Subject: [PATCH v8 1/6] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also have those prefixing attributes that equal the
scankey.

We cannot generally propagate this information to _binsrch on
lower pages, as this downstream page may have concurrently split
and/or have merged with its deleted left neighbour (see [0]),
which moves the keyspace of the linked page. We thus can only
trust the current state of this current page for this optimization,
which means we must validate this state each time we open the page.

Although this limits the overall applicability of the
performance improvement, it still allows for a nice performance
improvement in most cases where initial columns have many
duplicate values and a compare function that is not cheap.

As an exception to the above rule, most of the time a pages'
highkey is equal to the right seperator on the parent page due to
how btree splits are done. By storing this right seperator from
the parent page and then validating that the highkey of the child
page contains the exact same data, we can restore the right prefix
bound without having to call the relatively expensive _bt_compare.

In the worst-case scenario of a concurrent page split, we'd still
have to validate the full key, but that doesn't happen very often
when compared to the number of times we descend the btree.
---
 contrib/amcheck/verify_nbtree.c       |  17 ++--
 reproducer.bench.sql                  |   8 ++
 src/backend/access/nbtree/README      |  42 +++++++++
 src/backend/access/nbtree/nbtinsert.c |  34 +++++---
 src/backend/access/nbtree/nbtsearch.c | 119 +++++++++++++++++++++++---
 src/include/access/nbtree.h           |  10 ++-
 6 files changed, 196 insertions(+), 34 deletions(-)
 create mode 100644 reproducer.bench.sql

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 257cff671b..22bb229820 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2701,6 +2701,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2710,13 +2711,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2778,6 +2779,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2788,7 +2790,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2840,10 +2842,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2863,10 +2866,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2901,13 +2905,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/reproducer.bench.sql b/reproducer.bench.sql
new file mode 100644
index 0000000000..76cd8d481e
--- /dev/null
+++ b/reproducer.bench.sql
@@ -0,0 +1,8 @@
+BEGIN;
+SELECT omg.*
+FROM something_is_wrong_here AS omg
+ORDER BY random()
+LIMIT 1
+\gset
+UPDATE something_is_wrong_here SET value = :value + 1 WHERE id = :id;
+END;
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index dd0f7ad2bd..4d7fa5aff4 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,48 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+saving the indirect function calls in the compare operation.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by a parent page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. [2,3) to [1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+There is positive news, though: A page split will put a binary copy of the
+page's highkey in the parent page. This means that we usually can reuse
+the compare result of the parent page's downlink's right sibling when we
+discover that their representation is binary equal. In general this will
+be the case, as only in concurrent page splits and deletes the downlink
+may not point to the page with the correct highkey bound (_bt_moveright
+only rarely actually moves right).
+
+To implement this, we copy the downlink's right differentiator key into a
+temporary buffer, which is then compared against the child pages' highkey.
+If they match, we reuse the compare result (plus prefix) we had for it from
+the parent page, if not, we need to do a full _bt_compare. Because memcpy +
+memcmp is cheap compared to _bt_compare, and because it's quite unlikely
+that we guess wrong this speeds up our _bt_moveright code (at cost of some
+stack memory in _bt_search and some overhead in case of a wrong prediction)
+
+Now that we have prefix bounds on the highest value of a page, the
+_bt_binsrch procedure will use this result as a rightmost prefix compare,
+and for each step in the binary search (that does not compare less than the
+insert key) improve the equal-prefix bounds.
+
+Using the above optimization, we now (on average) only need 2 full key
+compares per page, as opposed to ceil(log2(ntupsperpage)) + 1; a significant
+improvement.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index f4c1a974ef..4c3bdefae2 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -326,6 +326,7 @@ _bt_search_insert(Relation rel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -344,7 +345,8 @@ _bt_search_insert(Relation rel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -438,7 +440,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = _bt_binsrch_insert(rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -448,6 +450,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -483,7 +487,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(_bt_compare(rel, itup_key, page, offset, &cmpcol) < 0);
 				break;
 			}
 
@@ -508,7 +512,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (_bt_compare(rel, itup_key, page, offset, &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -718,11 +722,12 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -865,6 +870,8 @@ _bt_findinsertloc(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
+
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -882,7 +889,7 @@ _bt_findinsertloc(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, insertstate, stack);
@@ -935,6 +942,8 @@ _bt_findinsertloc(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
+
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -965,7 +974,7 @@ _bt_findinsertloc(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -980,10 +989,13 @@ _bt_findinsertloc(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -1002,7 +1014,7 @@ _bt_findinsertloc(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index c43c1a2830..e3b828137b 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,7 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
 static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
@@ -98,6 +99,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
 
 	/* Get the root page to start with */
 	*bufP = _bt_getroot(rel, access);
@@ -130,7 +133,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * opportunity to finish splits of internal pages too.
 		 */
 		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot);
+							  page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -142,12 +146,15 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -181,6 +188,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		highkeycmpcol = 1;
+
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -191,7 +200,7 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
 	}
 
 	return stack_in;
@@ -239,12 +248,16 @@ _bt_moveright(Relation rel,
 			  bool forupdate,
 			  BTStack stack,
 			  int access,
-			  Snapshot snapshot)
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
+
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
 	 * this page is > the high key stored on the page, then the page has split
@@ -266,12 +279,17 @@ _bt_moveright(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -297,14 +315,55 @@ _bt_moveright(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
 		{
+			*comparecol = 1;
 			/* step right one page */
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -337,7 +396,8 @@ _bt_moveright(Relation rel,
 static OffsetNumber
 _bt_binsrch(Relation rel,
 			BTScanInsert key,
-			Buffer buf)
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -345,6 +405,8 @@ _bt_binsrch(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -386,16 +448,25 @@ _bt_binsrch(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
+	
+	*highkeycmpcol = highcmpcol;
 
 	/*
 	 * At this point we have high == low, but be careful: they could point
@@ -439,7 +510,8 @@ _bt_binsrch(Relation rel,
  * list split).
  */
 OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -449,6 +521,7 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -499,16 +572,22 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
+
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -656,7 +735,8 @@ int32
 _bt_compare(Relation rel,
 			BTScanInsert key,
 			Page page,
-			OffsetNumber offnum)
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -696,8 +776,9 @@ _bt_compare(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
 	{
 		Datum		datum;
 		bool		isNull;
@@ -741,11 +822,20 @@ _bt_compare(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = i;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
@@ -876,6 +966,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	AttrNumber	cmpcol = 1;
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1392,7 +1483,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = _bt_binsrch(rel, &inskey, buf, &cmpcol);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 8f48960f9d..4cb24fa005 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1232,9 +1232,13 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
 						  int access, Snapshot snapshot);
 extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
+							bool forupdate, BTStack stack, int access,
+							Snapshot snapshot, AttrNumber *comparecol,
+							char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
-- 
2.39.0

From 50ed073da7a6ba52c5e00e765e1959cf305f3f3b Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 12 Jan 2023 21:34:36 +0100
Subject: [PATCH v8 5/6] Add an attcacheoff-populating function

It populates attcacheoff-capable attributes with the correct offset,
and fills attributes whose offset is uncacheable with an 'uncacheable'
indicator value; as opposed to -1 which signals "unknown".

This allows users of the API to remove redundant cycles that try to
cache the offset of attributes - instead of O(N-attrs) operations, this
one only requires a O(1) check.
---
 src/backend/access/common/tupdesc.c | 111 ++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |   2 +
 2 files changed, 113 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 72a2c3d3db..f2d80ed0db 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -919,3 +919,114 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid offset value.
+ *
+ * Populates attcacheoff with a negative cache value when no offset
+ * can be calculated (due to e.g. variable length attributes).
+ * The negative value is a value relative to the last cacheable attribute
+ *   attcacheoff = -1 - (thisattno - cachedattno)
+ * so that the last attribute with cached offset can be found with
+ *   cachedattno = attcacheoff + 1 + thisattno
+ *   
+ * The value returned is the AttrNumber of the last (1-based) attribute that
+ * had its offset cached.
+ * 
+ * When the TupleDesc has 0 attributes, it returns 0.
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	currAttNo, lastCachedAttNo;
+
+	if (numberOfAttributes == 0)
+		return 0;
+
+	/* Non-negative value: this attribute is cached */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff >= 0)
+		return (AttrNumber) desc->natts;
+	/*
+	 * Attribute has been filled with relative offset to last cached value, but
+	 * it itself is unreachable.
+	 */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+		return (AttrNumber) (TupleDescAttr(desc, desc->natts - 1)->attcacheoff + 1 + desc->natts);
+
+	/* last attribute of the tupledesc may or may not support attcacheoff */
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	currAttNo = 1;
+	/*
+	 * Other code may have populated the value previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (currAttNo < numberOfAttributes &&
+		   TupleDescAttr(desc, currAttNo)->attcacheoff >= 0)
+		currAttNo++;
+
+	/*
+	 * Cache offset is undetermined. Start calculating offsets if possible.
+	 * 
+	 * When we exit this block, currAttNo will point at the first uncacheable
+	 * attribute, or past the end of the attribute array.
+	 */
+	if (currAttNo < numberOfAttributes &&
+		TupleDescAttr(desc, currAttNo)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, currAttNo - 1);
+		int32 off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (currAttNo < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, currAttNo);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+					{
+						att->attcacheoff = off;
+						currAttNo++;
+					}
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				currAttNo++;
+			}
+		}
+	}
+
+	Assert(currAttNo == numberOfAttributes || (
+		currAttNo < numberOfAttributes
+		&& TupleDescAttr(desc, (currAttNo - 1))->attcacheoff >= 0
+		&& TupleDescAttr(desc, currAttNo)->attcacheoff == -1
+	));
+	/*
+	 * No cacheable offsets left. Fill the rest with negative cache values,
+	 * but return the latest cached offset.
+	 */
+	lastCachedAttNo = currAttNo;
+
+	while (currAttNo < numberOfAttributes)
+	{
+		TupleDescAttr(desc, currAttNo)->attcacheoff = -1 - (currAttNo - lastCachedAttNo);
+		currAttNo++;
+	}
+
+	return lastCachedAttNo;
+}
\ No newline at end of file
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index b4286cf922..2673f2d0f3 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.39.0

From a81ec04ab71763095f9a2218d76dfa95aa89f489 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 20:04:56 +0100
Subject: [PATCH v8 4/6] Optimize nbts_attiter for nkeyatts==1 btrees

This removes the index_getattr_nocache call path, which has significant overhead, and uses constant 0 offset.
---
 src/backend/access/nbtree/README        |  1 +
 src/backend/access/nbtree/nbtree_spec.c |  3 ++
 src/include/access/nbtree.h             | 35 +++++++++++++
 src/include/access/nbtree_spec.h        | 68 +++++++++++++++++++++++--
 4 files changed, 102 insertions(+), 5 deletions(-)

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 4b11ea9ad7..6864902637 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1104,6 +1104,7 @@ in the index AM to call the specialized functions, increasing the
 performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
+ - indexes with only a single key attribute
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 6b766581ab..21635397ed 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_SINGLE_KEYATT:
+			_bt_specialize_single_keyatt(rel);
+			break;
 		case NBTS_CTX_DEFAULT:
 			break;
 	}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index f3f0961052..4628c41e9a 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1123,6 +1123,7 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
 typedef enum NBTS_CTX {
+	NBTS_CTX_SINGLE_KEYATT, 
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
@@ -1132,9 +1133,43 @@ static inline NBTS_CTX _nbt_spec_context(Relation irel)
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
+	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+		return NBTS_CTX_SINGLE_KEYATT;
+
 	return NBTS_CTX_CACHED;
 }
 
+static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
+									bool *isNull)
+{
+	Datum	result;
+	if (IndexTupleHasNulls(tuple))
+	{
+		if (att_isnull(0, (bits8 *)(tuple) + sizeof(IndexTupleData)))
+		{
+			*isNull = true;
+			result = (Datum) 0;
+		}
+		else
+		{
+			*isNull = false;
+			result = fetchatt(TupleDescAttr(tupleDesc, 0),
+							  ((char *) tuple)
+							  + MAXALIGN(sizeof(IndexTupleData)
+							  + sizeof(IndexAttributeBitMapData)));
+		}
+	}
+	else
+	{
+		*isNull = false;
+		result = fetchatt(TupleDescAttr(tupleDesc, 0),
+						  ((char *) tuple)
+						  + MAXALIGN(sizeof(IndexTupleData)));
+	}
+
+	return result;
+}
+
 
 #define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
 #include "nbtree_spec.h"
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 6ddba4d520..3ad64aad39 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -43,6 +43,7 @@
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_KEYATT single_keyatt
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -50,8 +51,10 @@
 /* contextual specializations */
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
-	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
+		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		) \
 	) \
 )
 
@@ -72,9 +75,9 @@ do { \
 } while (false)
 
 /*
- * Call a potentially specialized function for a given btree operation.
- *
- * NB: the rel argument is evaluated multiple times.
+ * Protections against multiple inclusions - the definition of this macro is
+ * different for files included with the templating mechanism vs the users
+ * of this template, so redefine these macros at top and bottom.
  */
 #ifdef NBTS_FUNCTION
 #undef NBTS_FUNCTION
@@ -164,6 +167,61 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 3: SINGLE_KEYATT
+ *
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path cannot be used for indexes with multiple key
++ *  columns, because it never considers the next column.
+ */
+
+/* the default context (and later contexts) do need to specialize, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel)
+
+#define NBTS_SPECIALIZING_SINGLE_KEYATT
+#define NBTS_TYPE NBTS_TYPE_SINGLE_KEYATT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	_bt_getfirstatt(itup, tupDesc, &NBTS_MAKE_NAME(itup, isNull)) \
+)
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_KEYATT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * All subsequent contexts are from non-templated code, so
+ * they need to actually include the context.
+ */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
 /*
  * from here on all NBTS_FUNCTIONs are from specialized function names that
  * are being called. Change the result of those macros from a direct call
-- 
2.39.0

From 5f95f55469291c188049c5042982ab4cdcb0ca91 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:57:21 +0100
Subject: [PATCH v8 3/6] Use specialized attribute iterators in the specialized
 source files

This is committed separately to make clear what substantial changes were
made to the pre-existing code.

Even though not all nbt*_spec functions have been updated; these functions
can now directly call (and inline, and optimize for) the specialized functions
they call, instead of having to determine the right specialization based on
the (potentially locally unavailable) index relation, making the specialization
of those functions still worth specializing/duplicating.
---
 src/backend/access/nbtree/nbtsearch_spec.c    | 18 +++---
 src/backend/access/nbtree/nbtsort_spec.c      | 24 +++----
 src/backend/access/nbtree/nbtutils_spec.c     | 62 ++++++++++++-------
 .../utils/sort/tuplesortvariants_spec.c       | 54 +++++++++-------
 src/include/access/nbtree_spec.h              | 10 +--
 5 files changed, 95 insertions(+), 73 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index 37cc3647d3..4ce39e7724 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -632,6 +632,7 @@ _bt_compare(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -664,23 +665,26 @@ _bt_compare(Relation rel,
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 
 	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
@@ -709,7 +713,7 @@ _bt_compare(Relation rel,
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
 		{
-			*comparecol = i;
+			*comparecol = nbts_attiter_attnum;
 			return result;
 		}
 
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index 368d6f244c..6f33cc4cc2 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -34,8 +34,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -57,7 +56,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -90,21 +89,24 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 			else if (itup != NULL)
 			{
 				int32		compare = 0;
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index 0288da22d6..07ca18f404 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -64,7 +64,7 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -95,7 +95,10 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -106,27 +109,30 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -675,6 +681,8 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -686,20 +694,22 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -707,6 +717,7 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -747,24 +758,27 @@ _bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 0791f41136..61c4826853 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -40,11 +40,8 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 	bool		equal_hasnull = false;
 	int			nkey;
 	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
 
 	/* Compare the leading sort key */
 	compare = ApplySortComparator(a->datum1, a->isnull1,
@@ -59,37 +56,46 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 	keysz = base->nKeys;
 	tupDes = RelationGetDescr(arg->index.indexRel);
 
-	if (sortKey->abbrev_converter)
+	if (!sortKey->abbrev_converter)
 	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
+		nkey = 2;
+		sortKey++;
+	}
+	else
+	{
+		nkey = 1;
 	}
 
 	/* they are equal, so we only need to examine one null flag */
 	if (a->isnull1)
 		equal_hasnull = true;
 
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
 	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+		Datum	datum1,
+				datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		else
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
 
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
 		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
+			return compare;
 
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
+		if (nbts_attiter_curattisnull(tuple1))
 			equal_hasnull = true;
+
+		sortKey++;
 	}
 
 	/*
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 0bfb623f37..6ddba4d520 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -66,15 +66,11 @@ do { \
 	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
 	{ \
 		nbts_prep_ctx(rel); \
+		Assert(PointerIsValid(rel)); \
 		_bt_specialize(rel); \
 	} \
 } while (false)
 
-/*
- * Access a specialized nbtree function, based on the shape of the index key.
- */
-#define NBTS_DEFINITIONS
-
 /*
  * Call a potentially specialized function for a given btree operation.
  *
@@ -102,7 +98,7 @@ do { \
 #define nbts_attiterdeclare(itup) \
 	bool	NBTS_MAKE_NAME(itup, isNull)
 
-#define nbts_attiterinit(itup, initAttNum, tupDesc)
+#define nbts_attiterinit(itup, initAttNum, tupDesc) do {} while (false)
 
 #define nbts_foreachattr(initAttNum, endAttNum) \
 	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
@@ -132,7 +128,7 @@ do { \
  * "Default", externally accessible, not so much optimized functions
  */
 
-/* the default context (and later contexts) do need to specialize, so here's that */
+/* the default context needs to specialize, so here's that */
 #undef nbts_prep_ctx
 #define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
 
-- 
2.39.0

From b067f08567da4e1f6ad628e1fef3c058370396d2 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:13:04 +0100
Subject: [PATCH v8 2/6] Specialize nbtree functions on btree key shape.

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, and splits the code that can
benefit from attribute offset optimizations into separate files. This does
NOT yet update the code itself - it just makes the code compile cleanly.
The performance should be comparable if not the same.
---
 contrib/amcheck/verify_nbtree.c               |    7 +
 src/backend/access/nbtree/README              |   33 +-
 src/backend/access/nbtree/nbtdedup.c          |  300 +----
 src/backend/access/nbtree/nbtdedup_spec.c     |  317 +++++
 src/backend/access/nbtree/nbtinsert.c         |  566 +--------
 src/backend/access/nbtree/nbtinsert_spec.c    |  583 +++++++++
 src/backend/access/nbtree/nbtpage.c           |    1 +
 src/backend/access/nbtree/nbtree.c            |   37 +-
 src/backend/access/nbtree/nbtree_spec.c       |   69 ++
 src/backend/access/nbtree/nbtsearch.c         | 1075 +---------------
 src/backend/access/nbtree/nbtsearch_spec.c    | 1087 +++++++++++++++++
 src/backend/access/nbtree/nbtsort.c           |  264 +---
 src/backend/access/nbtree/nbtsort_spec.c      |  280 +++++
 src/backend/access/nbtree/nbtsplitloc.c       |    3 +
 src/backend/access/nbtree/nbtutils.c          |  754 +-----------
 src/backend/access/nbtree/nbtutils_spec.c     |  775 ++++++++++++
 src/backend/utils/sort/tuplesortvariants.c    |  144 +--
 .../utils/sort/tuplesortvariants_spec.c       |  158 +++
 src/include/access/nbtree.h                   |   45 +-
 src/include/access/nbtree_spec.h              |  180 +++
 src/include/access/nbtree_specfuncs.h         |   66 +
 21 files changed, 3609 insertions(+), 3135 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.c
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.c
 create mode 100644 src/backend/access/nbtree/nbtree_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.c
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.c
 create mode 100644 src/backend/utils/sort/tuplesortvariants_spec.c
 create mode 100644 src/include/access/nbtree_spec.h
 create mode 100644 src/include/access/nbtree_specfuncs.h

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 22bb229820..fb89d6ada2 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2680,6 +2680,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 	BTStack		stack;
 	Buffer		lbuf;
 	bool		exists;
+	nbts_prep_ctx(NULL);
 
 	key = _bt_mkscankey(state->rel, itup);
 	Assert(key->heapkeyspace && key->scantid != NULL);
@@ -2780,6 +2781,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2843,6 +2845,7 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2867,6 +2870,7 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2906,6 +2910,7 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2966,6 +2971,7 @@ palloc_btree_page(BtreeCheckState *state, BlockNumber blocknum)
 	Page		page;
 	BTPageOpaque opaque;
 	OffsetNumber maxoffset;
+	nbts_prep_ctx(NULL);
 
 	page = palloc(BLCKSZ);
 
@@ -3141,6 +3147,7 @@ static inline BTScanInsert
 bt_mkscankey_pivotsearch(Relation rel, IndexTuple itup)
 {
 	BTScanInsert skey;
+	nbts_prep_ctx(NULL);
 
 	skey = _bt_mkscankey(rel, itup);
 	skey->pivotsearch = true;
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 4d7fa5aff4..4b11ea9ad7 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -940,8 +940,9 @@ and for each step in the binary search (that does not compare less than the
 insert key) improve the equal-prefix bounds.
 
 Using the above optimization, we now (on average) only need 2 full key
-compares per page, as opposed to ceil(log2(ntupsperpage)) + 1; a significant
-improvement.
+compares per page (plus ceil(log2(ntupsperpage)) single-attribute compares),
+as opposed to the ceil(log2(ntupsperpage)) + 1 of a naive implementation;
+a significant improvement.
 
 Notes about deduplication
 -------------------------
@@ -1083,6 +1084,34 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+Notes about nbtree specialization
+---------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes
+with variable length attributes, due to our inability to cache the offset
+of each attribute into an on-disk tuple. To combat this, we'd have to either
+fully deserialize the tuple, or maintain our offset into the tuple as we
+iterate over the tuple's fields.
+
+Keeping track of this offset also has a non-negligible overhead too, so we'd
+prefer to not have to keep track of these offsets when we can use the cache.
+By specializing performance-sensitive search functions for these specific
+index tuple shapes and calling those selectively, we can keep the performance
+of cacheable attribute offsets where that is applicable, while improving
+performance where we currently would see O(n_atts^2) time iterating on
+variable-length attributes.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also the default path, and is comparatively slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 0349988cf5..4589ade267 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,260 +22,14 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
-			   Size newitemsz, bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple and add it to our temp page (newpage).
-			 * Else add pending interval's base tuple to the temp page as-is.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place, when this page's newly allocated right sibling page
-				 * gets its first deduplication pass).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -316,6 +70,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 	TM_IndexDeleteOp delstate;
 	bool		neverdedup;
 	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	nbts_prep_ctx(rel);
 
 	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
 	newitemsz += sizeof(ItemIdData);
@@ -752,55 +507,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
new file mode 100644
index 0000000000..584211fe66
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -0,0 +1,317 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtdedup_spec.c
+ *	  Index shape-specialized functions for nbtdedup.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtdedup_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_do_singleval NBTS_FUNCTION(_bt_do_singleval)
+
+static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
+							 OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
+			   Size newitemsz, bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				minoff,
+				maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+				 _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple and add it to our temp page (newpage).
+			 * Else add pending interval's base tuple to the temp page as-is.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place, when this page's newly allocated right sibling page
+				 * gets its first deduplication pass).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+_bt_do_singleval(Relation rel, Page page, BTDedupState state,
+				 OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 4c3bdefae2..ca8ea60ffb 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,17 +30,10 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
 static void _bt_stepright(Relation rel, BTInsertState insertstate, BTStack stack);
 static void _bt_insertonpg(Relation rel, BTScanInsert itup_key,
 						   Buffer buf,
@@ -73,313 +66,8 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
-					   itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-			AttrNumber	cmpcol = 1;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
-							&cmpcol) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
-
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
-					  NULL);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -423,6 +111,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	bool		inposting = false;
 	bool		prevalldead = true;
 	int			curposti = 0;
+	nbts_prep_ctx(rel);
 
 	/* Assume unique until we find a duplicate */
 	*is_unique = true;
@@ -774,253 +463,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				AttrNumber	cmpcol = 1;
-
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
-					break;
-
-				_bt_stepright(rel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			AttrNumber	cmpcol = 1;
-
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	{
-		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
-		Assert(P_RIGHTMOST(opaque) ||
-			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
-	}
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1501,6 +943,7 @@ _bt_split(Relation rel, BTScanInsert itup_key, Buffer buf, Buffer cbuf,
 	bool		newitemonleft,
 				isleaf,
 				isrightmost;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * origpage is the original page to be split.  leftpage is a temporary
@@ -2693,6 +2136,7 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 	BTScanInsert itup_key = insertstate->itup_key;
 	Page		page = BufferGetPage(buffer);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
+	nbts_prep_ctx(rel);
 
 	Assert(P_ISLEAF(opaque));
 	Assert(simpleonly || itup_key->heapkeyspace);
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
new file mode 100644
index 0000000000..d37afae5ae
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -0,0 +1,583 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtinsert_spec.c
+ *	  Index shape-specialized functions for nbtinsert.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtinsert_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_search_insert NBTS_FUNCTION(_bt_search_insert)
+#define _bt_findinsertloc NBTS_FUNCTION(_bt_findinsertloc)
+
+static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
+static OffsetNumber _bt_findinsertloc(Relation rel,
+									  BTInsertState insertstate,
+									  bool checkingunique,
+									  bool indexUnchanged,
+									  BTStack stack,
+									  Relation heapRel);
+
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+_bt_doinsert(Relation rel, IndexTuple itup,
+			 IndexUniqueCheck checkUnique, bool indexUnchanged,
+			 Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = _bt_mkscankey(rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = _bt_search_insert(rel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
+									   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
+					   itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+_bt_search_insert(Relation rel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
+					  NULL);
+}
+
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+_bt_findinsertloc(Relation rel,
+				  BTInsertState insertstate,
+				  bool checkingunique,
+				  bool indexUnchanged,
+				  BTStack stack,
+				  Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				AttrNumber	cmpcol = 1;
+
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
+					break;
+
+				_bt_stepright(rel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			AttrNumber	cmpcol = 1;
+
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
+
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 3feee28d19..7710226f41 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1819,6 +1819,7 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 	bool		rightsib_empty;
 	Page		page;
 	BTPageOpaque opaque;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Save original leafbuf block number from caller.  Only deleted blocks
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 1cc88da032..ceeafd637f 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,8 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -120,7 +122,7 @@ bthandler(PG_FUNCTION_ARGS)
 
 	amroutine->ambuild = btbuild;
 	amroutine->ambuildempty = btbuildempty;
-	amroutine->aminsert = btinsert;
+	amroutine->aminsert = btinsert_default;
 	amroutine->ambulkdelete = btbulkdelete;
 	amroutine->amvacuumcleanup = btvacuumcleanup;
 	amroutine->amcanreturn = btcanreturn;
@@ -152,6 +154,8 @@ btbuildempty(Relation index)
 {
 	Page		metapage;
 
+	nbt_opt_specialize(index);
+
 	/* Construct metapage. */
 	metapage = (Page) palloc(BLCKSZ);
 	_bt_initmetapage(metapage, P_NONE, 0, _bt_allequalimage(index, false));
@@ -177,33 +181,6 @@ btbuildempty(Relation index)
 	smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
@@ -345,6 +322,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -788,6 +767,8 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
 
+	nbt_opt_specialize(rel);
+
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
 		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
new file mode 100644
index 0000000000..6b766581ab
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -0,0 +1,69 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_spec.c
+ *	  Index shape-specialized functions for nbtree.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtree_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+_bt_specialize(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	NBTS_MAKE_CTX(rel);
+	/*
+	 * We can't directly address _bt_specialize here because it'd be macro-
+	 * expanded, nor can we utilize NBTS_SPECIALIZE_NAME here because it'd
+	 * try to call _bt_specialize, which would be an infinite recursive call.
+	 */
+	switch (__nbts_ctx) {
+		case NBTS_CTX_CACHED:
+			_bt_specialize_cached(rel);
+			break;
+		case NBTS_CTX_DEFAULT:
+			break;
+	}
+#else
+	rel->rd_indam->aminsert = btinsert;
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+btinsert(Relation rel, Datum *values, bool *isnull,
+		 ItemPointer ht_ctid, Relation heapRel,
+		 IndexUniqueCheck checkUnique,
+		 bool indexUnchanged,
+		 IndexInfo *indexInfo)
+{
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index e3b828137b..0089fe7eeb 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,12 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
-								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -47,6 +43,8 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -71,572 +69,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- */
-BTStack
-_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
-		   Snapshot snapshot)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-	char		tupdatabuf[BLCKSZ / 3];
-	AttrNumber	highkeycmpcol = 1;
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot, &highkeycmpcol,
-							  (char *) tupdatabuf);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
-		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		highkeycmpcol = 1;
-
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split
- * is completed.  'stack' is only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  Snapshot snapshot,
-			  AttrNumber *comparecol,
-			  char *tupdatabuf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		AttrNumber	cmpcol = 1;
-
-		page = BufferGetPage(buf);
-		TestForOldSnapshot(snapshot, rel, page);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-		{
-			*comparecol = 1;
-			break;
-		}
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		/*
-		 * tupdatabuf is filled with the right seperator of the parent node.
-		 * This allows us to do a binary equality check between the parent
-		 * node's right seperator (which is < key) and this page's P_HIKEY.
-		 * If they equal, we can reuse the result of the parent node's
-		 * rightkey compare, which means we can potentially save a full key
-		 * compare (which includes indirect calls to attribute comparison
-		 * functions).
-		 * 
-		 * Without this, we'd on average use 3 full key compares per page before
-		 * we achieve full dynamic prefix bounds, but with this optimization
-		 * that is only 2.
-		 * 
-		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
-		 * we move right in the binary search on the page, this average equals
-		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
-		 */
-		if (!P_IGNORE(opaque) && *comparecol > 1)
-		{
-			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
-			IndexTuple buftuple = (IndexTuple) tupdatabuf;
-			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
-			{
-				char *dataptr = (char *) itup;
-
-				if (memcmp(dataptr + sizeof(IndexTupleData),
-						   tupdatabuf + sizeof(IndexTupleData),
-						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
-					break;
-			} else {
-				*comparecol = 1;
-			}
-		} else {
-			*comparecol = 1;
-		}
-
-		if (P_IGNORE(opaque) ||
-				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
-		{
-			*comparecol = 1;
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-		{
-			*comparecol = cmpcol;
-			break;
-		}
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf,
-			AttrNumber *highkeycmpcol)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-	AttrNumber	highcmpcol = *highkeycmpcol,
-				lowcmpcol = 1;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-		}
-	}
-	
-	*highkeycmpcol = highcmpcol;
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-				   AttrNumber highcmpcol)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-	AttrNumber	lowcmpcol = 1;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
-
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
  *
@@ -704,228 +136,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum,
-			AttrNumber *comparecol)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-
-	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-		{
-			*comparecol = i;
-			return result;
-		}
-
-		scankey++;
-	}
-
-	/*
-	 * All tuple attributes are equal to the scan key, only later attributes
-	 * could potentially not equal the scan key.
-	 */
-	*comparecol = ntupatts + 1;
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -967,6 +177,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(rel);
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1589,280 +800,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2071,12 +1008,11 @@ static bool
 _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 {
 	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Relation	rel;
+	Relation	rel = scan->indexRelation;
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
-
-	rel = scan->indexRelation;
+	nbts_prep_ctx(rel);
 
 	if (ScanDirectionIsForward(dir))
 	{
@@ -2488,6 +1424,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	BTPageOpaque opaque;
 	OffsetNumber start;
 	BTScanPosItem *currItem;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Scan down to the leftmost or rightmost leaf page.  This is a simplified
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
new file mode 100644
index 0000000000..37cc3647d3
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -0,0 +1,1087 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsearch_spec.c
+ *	  Index shape-specialized functions for nbtsearch.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsearch_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_binsrch		NBTS_FUNCTION(_bt_binsrch)
+#define _bt_readpage	NBTS_FUNCTION(_bt_readpage)
+
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
+static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
+						 OffsetNumber offnum);
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ */
+BTStack
+_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
+		   Snapshot snapshot)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
+							  page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		highkeycmpcol = 1;
+
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split
+ * is completed.  'stack' is only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ */
+Buffer
+_bt_moveright(Relation rel,
+			  BTScanInsert key,
+			  Buffer buf,
+			  bool forupdate,
+			  BTStack stack,
+			  int access,
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		AttrNumber	cmpcol = 1;
+
+		page = BufferGetPage(buf);
+		TestForOldSnapshot(snapshot, rel, page);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
+			break;
+		}
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+			_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
+		{
+			*comparecol = 1;
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+		{
+			*comparecol = cmpcol;
+			break;
+		}
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+_bt_binsrch(Relation rel,
+			BTScanInsert key,
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+		}
+	}
+
+	*highkeycmpcol = highcmpcol;
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+	AttrNumber	lowcmpcol = 1;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+_bt_compare(Relation rel,
+			BTScanInsert key,
+			Page page,
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+		{
+			*comparecol = i;
+			return result;
+		}
+
+		scankey++;
+	}
+
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 67b7b1710c..af408f704f 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,8 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -544,6 +544,7 @@ static void
 _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 {
 	BTWriteState wstate;
+	nbts_prep_ctx(btspool->index);
 
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
@@ -844,6 +845,7 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 	Size		pgspc;
 	Size		itupsz;
 	bool		isleaf;
+	nbts_prep_ctx(wstate->index);
 
 	/*
 	 * This is a handy place to check for cancel interrupts during the btree
@@ -1176,264 +1178,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			Assert(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
new file mode 100644
index 0000000000..368d6f244c
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -0,0 +1,280 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsort_spec.c
+ *	  Index shape-specialized functions for nbtsort.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsort_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_load NBTS_FUNCTION(_bt_load)
+
+static void _bt_load(BTWriteState *wstate,
+					 BTSpool *btspool, BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			Assert(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
+										 itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index ecb49bb471..991118fd50 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -639,6 +639,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	ItemId		itemid;
 	IndexTuple	tup;
 	int			keepnatts;
+	nbts_prep_ctx(state->rel);
 
 	Assert(state->is_leaf && !state->is_rightmost);
 
@@ -945,6 +946,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 			   *rightinterval;
 	int			perfectpenalty;
 	int			indnkeyatts = IndexRelationGetNumberOfKeyAttributes(state->rel);
+	nbts_prep_ctx(state->rel);
 
 	/* Assume that alternative strategy won't be used for now */
 	*strategy = SPLIT_DEFAULT;
@@ -1137,6 +1139,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 {
 	IndexTuple	lastleft;
 	IndexTuple	firstright;
+	nbts_prep_ctx(state->rel);
 
 	if (!state->is_leaf)
 	{
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 8003583c0a..85f92adda8 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,10 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.c"
+#include "access/nbtree_spec.h"
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1220,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1703,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
new file mode 100644
index 0000000000..0288da22d6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -0,0 +1,775 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtutils_spec.c
+ *	  Index shape-specialized functions for nbtutils.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtutils_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_check_rowcompare	NBTS_FUNCTION(_bt_check_rowcompare)
+#define _bt_keep_natts			NBTS_FUNCTION(_bt_keep_natts)
+
+static bool _bt_check_rowcompare(ScanKey skey,
+								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+								 ScanDirection dir, bool *continuescan);
+static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
+							 IndexTuple firstright, BTScanInsert itup_key);
+
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+_bt_mkscankey(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+			  ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
+									 continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
+					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			 BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			   BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index eb6cfcfd00..12f909e1cf 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -57,8 +57,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int tuplen);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static void writetup_index(Tuplesortstate *state, LogicalTape *tape,
@@ -130,6 +128,9 @@ typedef struct
 	int			datumTypeLen;
 } TuplesortDatumArg;
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesortvariants_spec.c"
+#include "access/nbtree_spec.h"
+
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
 					 int nkeys, AttrNumber *attNums,
@@ -217,6 +218,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 	MemoryContext oldcontext;
 	TuplesortClusterArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	Assert(indexRel->rd_rel->relam == BTREE_AM_OID);
 
@@ -328,6 +330,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	TuplesortIndexBTreeArg *arg;
 	MemoryContext oldcontext;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -461,6 +464,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 	MemoryContext oldcontext;
 	TuplesortIndexBTreeArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -1259,142 +1263,6 @@ removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
 	}
 }
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
-	SortSupport sortKey = base->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = base->nKeys;
-	tupDes = RelationGetDescr(arg->index.indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(arg->index.indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(arg->index.heapRel,
-									RelationGetRelationName(arg->index.indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
new file mode 100644
index 0000000000..0791f41136
--- /dev/null
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -0,0 +1,158 @@
+/*-------------------------------------------------------------------------
+ *
+ * tuplesortvariants_spec.c
+ *	  Index shape-specialized functions for tuplesortvariants.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/tuplesortvariants_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define comparetup_index_btree NBTS_FUNCTION(comparetup_index_btree)
+
+static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+								   Tuplesortstate *state);
+
+static int
+comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+					   Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
+	SortSupport sortKey = base->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	Datum		datum1,
+				datum2;
+	bool		isnull1,
+				isnull2;
+
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = base->nKeys;
+	tupDes = RelationGetDescr(arg->index.indexRel);
+
+	if (sortKey->abbrev_converter)
+	{
+		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
+
+		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
+												datum2, isnull2,
+												sortKey);
+		if (compare != 0)
+			return compare;
+	}
+
+	/* they are equal, so we only need to examine one null flag */
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	sortKey++;
+	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	{
+		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+
+		compare = ApplySortComparator(datum1, isnull1,
+									  datum2, isnull2,
+									  sortKey);
+		if (compare != 0)
+			return compare;		/* done when we find unequal attributes */
+
+		/* they are equal, so we only need to examine one null flag */
+		if (isnull1)
+			equal_hasnull = true;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(arg->index.indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(arg->index.heapRel,
+									   RelationGetRelationName(arg->index.indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 4cb24fa005..f3f0961052 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1122,15 +1122,27 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+typedef enum NBTS_CTX {
+	NBTS_CTX_CACHED, 
+	NBTS_CTX_DEFAULT, /* fallback */
+} NBTS_CTX;
+
+static inline NBTS_CTX _nbt_spec_context(Relation irel)
+{
+	if (!PointerIsValid(irel))
+		return NBTS_CTX_DEFAULT;
+
+	return NBTS_CTX_CACHED;
+}
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
+#include "nbtree_spec.h"
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1161,9 +1173,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
-						   IndexTuple newitem, Size newitemsz,
-						   bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1179,9 +1188,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Buffer lbuf, BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, BTStack stack, BlockNumber child);
 
@@ -1229,16 +1235,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
-						  int access, Snapshot snapshot);
-extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access,
-							Snapshot snapshot, AttrNumber *comparecol,
-							char *tupdatabuf);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-									   AttrNumber highcmpcol);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
-						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
@@ -1247,7 +1243,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1255,8 +1250,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1269,10 +1262,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
new file mode 100644
index 0000000000..0bfb623f37
--- /dev/null
+++ b/src/include/access/nbtree_spec.h
@@ -0,0 +1,180 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ * - nbts_context(irel)
+ *   Constructs a context that is used to call specialized functions.
+ *   Note that this is optional in paths that are inaccessible to unspecialized
+ *   code paths, but should be included in NBTS_BUILD_GENERIC.
+ */
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+#define NBTS_CTX_NAME __nbts_ctx
+
+/* contextual specializations */
+#define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
+#define NBTS_SPECIALIZE_NAME(name) ( \
+	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	) \
+)
+
+/* how do we make names? */
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define nbt_opt_specialize(rel) \
+do { \
+	Assert(PointerIsValid(rel)); \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
+	{ \
+		nbts_prep_ctx(rel); \
+		_bt_specialize(rel); \
+	} \
+} while (false)
+
+/*
+ * Access a specialized nbtree function, based on the shape of the index key.
+ */
+#define NBTS_DEFINITIONS
+
+/*
+ * Call a potentially specialized function for a given btree operation.
+ *
+ * NB: the rel argument is evaluated multiple times.
+ */
+#ifdef NBTS_FUNCTION
+#undef NBTS_FUNCTION
+#endif
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+/* While specializing, the context is the local context */
+#ifdef nbts_prep_ctx
+#undef nbts_prep_ctx
+#endif
+#define nbts_prep_ctx(rel)
+
+/*
+ * Specialization 1: CACHED
+ *
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_SPECIALIZING_CACHED
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * Specialization 2: DEFAULT
+ *
+ * "Default", externally accessible, not so much optimized functions
+ */
+
+/* the default context (and later contexts) do need to specialize, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * from here on all NBTS_FUNCTIONs are from specialized function names that
+ * are being called. Change the result of those macros from a direct call
+ * call to a conditional call to the right place, depending on the correct
+ * context.
+ */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) NBTS_SPECIALIZE_NAME(name)
+
+#undef NBT_SPECIALIZE_FILE
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
new file mode 100644
index 0000000000..ac60319eff
--- /dev/null
+++ b/src/include/access/nbtree_specfuncs.h
@@ -0,0 +1,66 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+#define _bt_specialize		NBTS_FUNCTION(_bt_specialize)
+#define btinsert			NBTS_FUNCTION(btinsert)
+#define _bt_dedup_pass		NBTS_FUNCTION(_bt_dedup_pass)
+#define _bt_doinsert		NBTS_FUNCTION(_bt_doinsert)
+#define _bt_search			NBTS_FUNCTION(_bt_search)
+#define _bt_moveright		NBTS_FUNCTION(_bt_moveright)
+#define _bt_binsrch_insert	NBTS_FUNCTION(_bt_binsrch_insert)
+#define _bt_compare			NBTS_FUNCTION(_bt_compare)
+#define _bt_mkscankey		NBTS_FUNCTION(_bt_mkscankey)
+#define _bt_checkkeys		NBTS_FUNCTION(_bt_checkkeys)
+#define _bt_truncate		NBTS_FUNCTION(_bt_truncate)
+#define _bt_keep_natts_fast	NBTS_FUNCTION(_bt_keep_natts_fast)
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void _bt_specialize(Relation rel);
+
+extern bool btinsert(Relation rel, Datum *values, bool *isnull,
+					 ItemPointer ht_ctid, Relation heapRel,
+					 IndexUniqueCheck checkUnique, bool indexUnchanged,
+					 struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
+						   IndexTuple newitem, Size newitemsz,
+						   bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool _bt_doinsert(Relation rel, IndexTuple itup,
+						 IndexUniqueCheck checkUnique, bool indexUnchanged,
+						 Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
+						  int access, Snapshot snapshot);
+extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
+							bool forupdate, BTStack stack, int access,
+							Snapshot snapshot, AttrNumber *comparecol,
+							char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
+extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+						  ScanDirection dir, bool *continuescan);
+extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright, BTScanInsert itup_key);
+extern int _bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright);
-- 
2.39.0

From 6b5092fd1842b66c9a894aef8e12043cf30bebb0 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 13 Jan 2023 15:42:41 +0100
Subject: [PATCH v8 6/6] btree specialization for variable-length
 multi-attribute keys

The default code path is relatively slow at O(n^2), so with multiple
attributes we accept the increased startup cost in favour of lower
costs for later attributes.

Note that this will only be used for indexes that use at least one
variable-length key attribute (except as last key attribute in specific
cases).
---
 src/backend/access/nbtree/README        |  10 +-
 src/backend/access/nbtree/nbtree_spec.c |   3 +
 src/include/access/itup_attiter.h       | 198 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  11 +-
 src/include/access/nbtree_spec.h        |  48 +++++-
 5 files changed, 259 insertions(+), 11 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 6864902637..2219c58242 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1104,15 +1104,13 @@ in the index AM to call the specialized functions, increasing the
 performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
- - indexes with only a single key attribute
- - multi-column indexes that could benefit from the attcacheoff optimization
+ - indexes with only a single key attribute,
+ - multi-column indexes that cannot pre-calculate the offsets of all key
+   attributes in the tuple data section,
+ - multi-column indexes that do benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
 
-Future work will optimize for multi-column indexes that don't benefit
-from the attcacheoff optimization by improving on the O(n^2) nature of
-index_getattr through storing attribute offsets.
-
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 21635397ed..699197dfa7 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_UNCACHED:
+			_bt_specialize_uncached(rel);
+			break;
 		case NBTS_CTX_SINGLE_KEYATT:
 			_bt_specialize_single_keyatt(rel);
 			break;
diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..7dd10b4cf0
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,198 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup_attiter.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 4628c41e9a..d5ed38bb71 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1124,18 +1125,26 @@ typedef struct BTOptions
 
 typedef enum NBTS_CTX {
 	NBTS_CTX_SINGLE_KEYATT, 
+	NBTS_CTX_UNCACHED,
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	AttrNumber	nKeyAtts;
+
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
-	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+	nKeyAtts = IndexRelationGetNumberOfKeyAttributes(irel);
+
+	if (nKeyAtts == 1)
 		return NBTS_CTX_SINGLE_KEYATT;
 
+	if (TupleDescAttr(irel->rd_att, nKeyAtts - 1)->attcacheoff < -1)
+		return NBTS_CTX_UNCACHED;
+
 	return NBTS_CTX_CACHED;
 }
 
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 3ad64aad39..a57d69f588 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -44,6 +44,7 @@
  * Macros used in the nbtree specialization code.
  */
 #define NBTS_TYPE_SINGLE_KEYATT single_keyatt
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -52,8 +53,10 @@
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
 	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
-		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		(NBTS_CTX_NAME) == NBTS_CTX_UNCACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED)) : ( \
+			(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+				NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+			) \
 		) \
 	) \
 )
@@ -68,9 +71,12 @@ do { \
 	Assert(PointerIsValid(rel)); \
 	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
 	{ \
-		nbts_prep_ctx(rel); \
 		Assert(PointerIsValid(rel)); \
-		_bt_specialize(rel); \
+		PopulateTupleDescCacheOffsets(rel->rd_att); \
+		{ \
+			nbts_prep_ctx(rel); \
+			_bt_specialize(rel); \
+		} \
 	} \
 } while (false)
 
@@ -216,6 +222,40 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All subsequent contexts are from non-templated code, so
  * they need to actually include the context.
-- 
2.39.0

From 82abd6a316c079ac7b223af5a7a3dcb124447ea2 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 12 Jan 2023 21:34:36 +0100
Subject: [PATCH v9 5/6] Add an attcacheoff-populating function

It populates attcacheoff-capable attributes with the correct offset,
and fills attributes whose offset is uncacheable with an 'uncacheable'
indicator value; as opposed to -1 which signals "unknown".

This allows users of the API to remove redundant cycles that try to
cache the offset of attributes - instead of O(N-attrs) operations, this
one only requires a O(1) check.
---
 src/backend/access/common/tupdesc.c | 111 ++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |   2 +
 2 files changed, 113 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 72a2c3d3db..f2d80ed0db 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -919,3 +919,114 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid offset value.
+ *
+ * Populates attcacheoff with a negative cache value when no offset
+ * can be calculated (due to e.g. variable length attributes).
+ * The negative value is a value relative to the last cacheable attribute
+ *   attcacheoff = -1 - (thisattno - cachedattno)
+ * so that the last attribute with cached offset can be found with
+ *   cachedattno = attcacheoff + 1 + thisattno
+ *   
+ * The value returned is the AttrNumber of the last (1-based) attribute that
+ * had its offset cached.
+ * 
+ * When the TupleDesc has 0 attributes, it returns 0.
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	currAttNo, lastCachedAttNo;
+
+	if (numberOfAttributes == 0)
+		return 0;
+
+	/* Non-negative value: this attribute is cached */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff >= 0)
+		return (AttrNumber) desc->natts;
+	/*
+	 * Attribute has been filled with relative offset to last cached value, but
+	 * it itself is unreachable.
+	 */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+		return (AttrNumber) (TupleDescAttr(desc, desc->natts - 1)->attcacheoff + 1 + desc->natts);
+
+	/* last attribute of the tupledesc may or may not support attcacheoff */
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	currAttNo = 1;
+	/*
+	 * Other code may have populated the value previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (currAttNo < numberOfAttributes &&
+		   TupleDescAttr(desc, currAttNo)->attcacheoff >= 0)
+		currAttNo++;
+
+	/*
+	 * Cache offset is undetermined. Start calculating offsets if possible.
+	 * 
+	 * When we exit this block, currAttNo will point at the first uncacheable
+	 * attribute, or past the end of the attribute array.
+	 */
+	if (currAttNo < numberOfAttributes &&
+		TupleDescAttr(desc, currAttNo)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, currAttNo - 1);
+		int32 off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (currAttNo < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, currAttNo);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+					{
+						att->attcacheoff = off;
+						currAttNo++;
+					}
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				currAttNo++;
+			}
+		}
+	}
+
+	Assert(currAttNo == numberOfAttributes || (
+		currAttNo < numberOfAttributes
+		&& TupleDescAttr(desc, (currAttNo - 1))->attcacheoff >= 0
+		&& TupleDescAttr(desc, currAttNo)->attcacheoff == -1
+	));
+	/*
+	 * No cacheable offsets left. Fill the rest with negative cache values,
+	 * but return the latest cached offset.
+	 */
+	lastCachedAttNo = currAttNo;
+
+	while (currAttNo < numberOfAttributes)
+	{
+		TupleDescAttr(desc, currAttNo)->attcacheoff = -1 - (currAttNo - lastCachedAttNo);
+		currAttNo++;
+	}
+
+	return lastCachedAttNo;
+}
\ No newline at end of file
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index b4286cf922..2673f2d0f3 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.39.0

From f958f99b70daa497d85c3e1303bdf6e55975481d Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 20:04:56 +0100
Subject: [PATCH v9 4/6] Optimize nbts_attiter for nkeyatts==1 btrees

This removes the index_getattr_nocache call path, which has significant overhead, and uses constant 0 offset.
---
 src/backend/access/nbtree/README        |  1 +
 src/backend/access/nbtree/nbtree_spec.c |  3 ++
 src/include/access/nbtree.h             | 35 +++++++++++++
 src/include/access/nbtree_spec.h        | 68 +++++++++++++++++++++++--
 4 files changed, 102 insertions(+), 5 deletions(-)

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 4b11ea9ad7..6864902637 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1104,6 +1104,7 @@ in the index AM to call the specialized functions, increasing the
 performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
+ - indexes with only a single key attribute
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 6b766581ab..21635397ed 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_SINGLE_KEYATT:
+			_bt_specialize_single_keyatt(rel);
+			break;
 		case NBTS_CTX_DEFAULT:
 			break;
 	}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index f3f0961052..4628c41e9a 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1123,6 +1123,7 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
 typedef enum NBTS_CTX {
+	NBTS_CTX_SINGLE_KEYATT, 
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
@@ -1132,9 +1133,43 @@ static inline NBTS_CTX _nbt_spec_context(Relation irel)
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
+	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+		return NBTS_CTX_SINGLE_KEYATT;
+
 	return NBTS_CTX_CACHED;
 }
 
+static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
+									bool *isNull)
+{
+	Datum	result;
+	if (IndexTupleHasNulls(tuple))
+	{
+		if (att_isnull(0, (bits8 *)(tuple) + sizeof(IndexTupleData)))
+		{
+			*isNull = true;
+			result = (Datum) 0;
+		}
+		else
+		{
+			*isNull = false;
+			result = fetchatt(TupleDescAttr(tupleDesc, 0),
+							  ((char *) tuple)
+							  + MAXALIGN(sizeof(IndexTupleData)
+							  + sizeof(IndexAttributeBitMapData)));
+		}
+	}
+	else
+	{
+		*isNull = false;
+		result = fetchatt(TupleDescAttr(tupleDesc, 0),
+						  ((char *) tuple)
+						  + MAXALIGN(sizeof(IndexTupleData)));
+	}
+
+	return result;
+}
+
 
 #define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
 #include "nbtree_spec.h"
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 6ddba4d520..3ad64aad39 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -43,6 +43,7 @@
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_KEYATT single_keyatt
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -50,8 +51,10 @@
 /* contextual specializations */
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
-	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
+		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		) \
 	) \
 )
 
@@ -72,9 +75,9 @@ do { \
 } while (false)
 
 /*
- * Call a potentially specialized function for a given btree operation.
- *
- * NB: the rel argument is evaluated multiple times.
+ * Protections against multiple inclusions - the definition of this macro is
+ * different for files included with the templating mechanism vs the users
+ * of this template, so redefine these macros at top and bottom.
  */
 #ifdef NBTS_FUNCTION
 #undef NBTS_FUNCTION
@@ -164,6 +167,61 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 3: SINGLE_KEYATT
+ *
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path cannot be used for indexes with multiple key
++ *  columns, because it never considers the next column.
+ */
+
+/* the default context (and later contexts) do need to specialize, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel)
+
+#define NBTS_SPECIALIZING_SINGLE_KEYATT
+#define NBTS_TYPE NBTS_TYPE_SINGLE_KEYATT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	_bt_getfirstatt(itup, tupDesc, &NBTS_MAKE_NAME(itup, isNull)) \
+)
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_KEYATT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * All subsequent contexts are from non-templated code, so
+ * they need to actually include the context.
+ */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
 /*
  * from here on all NBTS_FUNCTIONs are from specialized function names that
  * are being called. Change the result of those macros from a direct call
-- 
2.39.0

From 9167050d806299d173a11947e5d7af0f508e82d3 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:57:21 +0100
Subject: [PATCH v9 3/6] Use specialized attribute iterators in the specialized
 source files

This is committed separately to make clear what substantial changes were
made to the pre-existing code.

Even though not all nbt*_spec functions have been updated; these functions
can now directly call (and inline, and optimize for) the specialized functions
they call, instead of having to determine the right specialization based on
the (potentially locally unavailable) index relation, making the specialization
of those functions still worth specializing/duplicating.
---
 src/backend/access/nbtree/nbtsearch_spec.c    | 18 +++---
 src/backend/access/nbtree/nbtsort_spec.c      | 24 +++----
 src/backend/access/nbtree/nbtutils_spec.c     | 62 ++++++++++++-------
 .../utils/sort/tuplesortvariants_spec.c       | 54 +++++++++-------
 src/include/access/nbtree_spec.h              | 10 +--
 5 files changed, 95 insertions(+), 73 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index 37cc3647d3..4ce39e7724 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -632,6 +632,7 @@ _bt_compare(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -664,23 +665,26 @@ _bt_compare(Relation rel,
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 
 	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
@@ -709,7 +713,7 @@ _bt_compare(Relation rel,
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
 		{
-			*comparecol = i;
+			*comparecol = nbts_attiter_attnum;
 			return result;
 		}
 
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index 368d6f244c..6f33cc4cc2 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -34,8 +34,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -57,7 +56,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -90,21 +89,24 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 			else if (itup != NULL)
 			{
 				int32		compare = 0;
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index 0288da22d6..07ca18f404 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -64,7 +64,7 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -95,7 +95,10 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -106,27 +109,30 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -675,6 +681,8 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -686,20 +694,22 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -707,6 +717,7 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -747,24 +758,27 @@ _bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 0791f41136..61c4826853 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -40,11 +40,8 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 	bool		equal_hasnull = false;
 	int			nkey;
 	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
 
 	/* Compare the leading sort key */
 	compare = ApplySortComparator(a->datum1, a->isnull1,
@@ -59,37 +56,46 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 	keysz = base->nKeys;
 	tupDes = RelationGetDescr(arg->index.indexRel);
 
-	if (sortKey->abbrev_converter)
+	if (!sortKey->abbrev_converter)
 	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
+		nkey = 2;
+		sortKey++;
+	}
+	else
+	{
+		nkey = 1;
 	}
 
 	/* they are equal, so we only need to examine one null flag */
 	if (a->isnull1)
 		equal_hasnull = true;
 
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
 	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+		Datum	datum1,
+				datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		else
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
 
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
 		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
+			return compare;
 
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
+		if (nbts_attiter_curattisnull(tuple1))
 			equal_hasnull = true;
+
+		sortKey++;
 	}
 
 	/*
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 0bfb623f37..6ddba4d520 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -66,15 +66,11 @@ do { \
 	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
 	{ \
 		nbts_prep_ctx(rel); \
+		Assert(PointerIsValid(rel)); \
 		_bt_specialize(rel); \
 	} \
 } while (false)
 
-/*
- * Access a specialized nbtree function, based on the shape of the index key.
- */
-#define NBTS_DEFINITIONS
-
 /*
  * Call a potentially specialized function for a given btree operation.
  *
@@ -102,7 +98,7 @@ do { \
 #define nbts_attiterdeclare(itup) \
 	bool	NBTS_MAKE_NAME(itup, isNull)
 
-#define nbts_attiterinit(itup, initAttNum, tupDesc)
+#define nbts_attiterinit(itup, initAttNum, tupDesc) do {} while (false)
 
 #define nbts_foreachattr(initAttNum, endAttNum) \
 	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
@@ -132,7 +128,7 @@ do { \
  * "Default", externally accessible, not so much optimized functions
  */
 
-/* the default context (and later contexts) do need to specialize, so here's that */
+/* the default context needs to specialize, so here's that */
 #undef nbts_prep_ctx
 #define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
 
-- 
2.39.0

From 6be07223db0c1855410dc2630935420bdc368b46 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Tue, 10 Jan 2023 21:45:44 +0100
Subject: [PATCH v9 1/6] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also have those prefixing attributes that equal the
scankey.

We cannot generally propagate this information to _binsrch on
lower pages, as this downstream page may have concurrently split
and/or have merged with its deleted left neighbour (see [0]),
which moves the keyspace of the linked page. We thus can only
trust the current state of this current page for this optimization,
which means we must validate this state each time we open the page.

Although this limits the overall applicability of the
performance improvement, it still allows for a nice performance
improvement in most cases where initial columns have many
duplicate values and a compare function that is not cheap.

As an exception to the above rule, most of the time a pages'
highkey is equal to the right seperator on the parent page due to
how btree splits are done. By storing this right seperator from
the parent page and then validating that the highkey of the child
page contains the exact same data, we can restore the right prefix
bound without having to call the relatively expensive _bt_compare.

In the worst-case scenario of a concurrent page split, we'd still
have to validate the full key, but that doesn't happen very often
when compared to the number of times we descend the btree.
---
 contrib/amcheck/verify_nbtree.c       |  17 ++--
 src/backend/access/nbtree/README      |  42 +++++++++
 src/backend/access/nbtree/nbtinsert.c |  34 +++++---
 src/backend/access/nbtree/nbtsearch.c | 119 +++++++++++++++++++++++---
 src/include/access/nbtree.h           |  10 ++-
 5 files changed, 188 insertions(+), 34 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 257cff671b..22bb229820 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2701,6 +2701,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2710,13 +2711,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2778,6 +2779,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2788,7 +2790,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2840,10 +2842,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2863,10 +2866,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2901,13 +2905,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index dd0f7ad2bd..4d7fa5aff4 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,48 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+saving the indirect function calls in the compare operation.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by a parent page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. [2,3) to [1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+There is positive news, though: A page split will put a binary copy of the
+page's highkey in the parent page. This means that we usually can reuse
+the compare result of the parent page's downlink's right sibling when we
+discover that their representation is binary equal. In general this will
+be the case, as only in concurrent page splits and deletes the downlink
+may not point to the page with the correct highkey bound (_bt_moveright
+only rarely actually moves right).
+
+To implement this, we copy the downlink's right differentiator key into a
+temporary buffer, which is then compared against the child pages' highkey.
+If they match, we reuse the compare result (plus prefix) we had for it from
+the parent page, if not, we need to do a full _bt_compare. Because memcpy +
+memcmp is cheap compared to _bt_compare, and because it's quite unlikely
+that we guess wrong this speeds up our _bt_moveright code (at cost of some
+stack memory in _bt_search and some overhead in case of a wrong prediction)
+
+Now that we have prefix bounds on the highest value of a page, the
+_bt_binsrch procedure will use this result as a rightmost prefix compare,
+and for each step in the binary search (that does not compare less than the
+insert key) improve the equal-prefix bounds.
+
+Using the above optimization, we now (on average) only need 2 full key
+compares per page, as opposed to ceil(log2(ntupsperpage)) + 1; a significant
+improvement.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index f4c1a974ef..4c3bdefae2 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -326,6 +326,7 @@ _bt_search_insert(Relation rel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -344,7 +345,8 @@ _bt_search_insert(Relation rel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -438,7 +440,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = _bt_binsrch_insert(rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -448,6 +450,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -483,7 +487,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(_bt_compare(rel, itup_key, page, offset, &cmpcol) < 0);
 				break;
 			}
 
@@ -508,7 +512,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (_bt_compare(rel, itup_key, page, offset, &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -718,11 +722,12 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -865,6 +870,8 @@ _bt_findinsertloc(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
+
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -882,7 +889,7 @@ _bt_findinsertloc(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, insertstate, stack);
@@ -935,6 +942,8 @@ _bt_findinsertloc(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
+
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -965,7 +974,7 @@ _bt_findinsertloc(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -980,10 +989,13 @@ _bt_findinsertloc(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -1002,7 +1014,7 @@ _bt_findinsertloc(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index c43c1a2830..e3b828137b 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,7 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
 static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
@@ -98,6 +99,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
 
 	/* Get the root page to start with */
 	*bufP = _bt_getroot(rel, access);
@@ -130,7 +133,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * opportunity to finish splits of internal pages too.
 		 */
 		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot);
+							  page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -142,12 +146,15 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -181,6 +188,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		highkeycmpcol = 1;
+
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -191,7 +200,7 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
 	}
 
 	return stack_in;
@@ -239,12 +248,16 @@ _bt_moveright(Relation rel,
 			  bool forupdate,
 			  BTStack stack,
 			  int access,
-			  Snapshot snapshot)
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
+
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
 	 * this page is > the high key stored on the page, then the page has split
@@ -266,12 +279,17 @@ _bt_moveright(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -297,14 +315,55 @@ _bt_moveright(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
 		{
+			*comparecol = 1;
 			/* step right one page */
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -337,7 +396,8 @@ _bt_moveright(Relation rel,
 static OffsetNumber
 _bt_binsrch(Relation rel,
 			BTScanInsert key,
-			Buffer buf)
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -345,6 +405,8 @@ _bt_binsrch(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -386,16 +448,25 @@ _bt_binsrch(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
+	
+	*highkeycmpcol = highcmpcol;
 
 	/*
 	 * At this point we have high == low, but be careful: they could point
@@ -439,7 +510,8 @@ _bt_binsrch(Relation rel,
  * list split).
  */
 OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -449,6 +521,7 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -499,16 +572,22 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
+
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -656,7 +735,8 @@ int32
 _bt_compare(Relation rel,
 			BTScanInsert key,
 			Page page,
-			OffsetNumber offnum)
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -696,8 +776,9 @@ _bt_compare(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
 	{
 		Datum		datum;
 		bool		isNull;
@@ -741,11 +822,20 @@ _bt_compare(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = i;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
@@ -876,6 +966,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	AttrNumber	cmpcol = 1;
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1392,7 +1483,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = _bt_binsrch(rel, &inskey, buf, &cmpcol);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 8f48960f9d..4cb24fa005 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1232,9 +1232,13 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
 						  int access, Snapshot snapshot);
 extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
+							bool forupdate, BTStack stack, int access,
+							Snapshot snapshot, AttrNumber *comparecol,
+							char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
-- 
2.39.0

From 53b4b1c4598c4269379299c7999c2acb8240fea1 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:13:04 +0100
Subject: [PATCH v9 2/6] Specialize nbtree functions on btree key shape.

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, and splits the code that can
benefit from attribute offset optimizations into separate files. This does
NOT yet update the code itself - it just makes the code compile cleanly.
The performance should be comparable if not the same.
---
 contrib/amcheck/verify_nbtree.c               |    7 +
 src/backend/access/nbtree/README              |   33 +-
 src/backend/access/nbtree/nbtdedup.c          |  300 +----
 src/backend/access/nbtree/nbtdedup_spec.c     |  317 +++++
 src/backend/access/nbtree/nbtinsert.c         |  566 +--------
 src/backend/access/nbtree/nbtinsert_spec.c    |  583 +++++++++
 src/backend/access/nbtree/nbtpage.c           |    1 +
 src/backend/access/nbtree/nbtree.c            |   37 +-
 src/backend/access/nbtree/nbtree_spec.c       |   69 ++
 src/backend/access/nbtree/nbtsearch.c         | 1075 +---------------
 src/backend/access/nbtree/nbtsearch_spec.c    | 1087 +++++++++++++++++
 src/backend/access/nbtree/nbtsort.c           |  264 +---
 src/backend/access/nbtree/nbtsort_spec.c      |  280 +++++
 src/backend/access/nbtree/nbtsplitloc.c       |    3 +
 src/backend/access/nbtree/nbtutils.c          |  754 +-----------
 src/backend/access/nbtree/nbtutils_spec.c     |  775 ++++++++++++
 src/backend/utils/sort/tuplesortvariants.c    |  144 +--
 .../utils/sort/tuplesortvariants_spec.c       |  158 +++
 src/include/access/nbtree.h                   |   45 +-
 src/include/access/nbtree_spec.h              |  180 +++
 src/include/access/nbtree_specfuncs.h         |   66 +
 21 files changed, 3609 insertions(+), 3135 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.c
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.c
 create mode 100644 src/backend/access/nbtree/nbtree_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.c
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.c
 create mode 100644 src/backend/utils/sort/tuplesortvariants_spec.c
 create mode 100644 src/include/access/nbtree_spec.h
 create mode 100644 src/include/access/nbtree_specfuncs.h

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 22bb229820..fb89d6ada2 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2680,6 +2680,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 	BTStack		stack;
 	Buffer		lbuf;
 	bool		exists;
+	nbts_prep_ctx(NULL);
 
 	key = _bt_mkscankey(state->rel, itup);
 	Assert(key->heapkeyspace && key->scantid != NULL);
@@ -2780,6 +2781,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2843,6 +2845,7 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2867,6 +2870,7 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2906,6 +2910,7 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2966,6 +2971,7 @@ palloc_btree_page(BtreeCheckState *state, BlockNumber blocknum)
 	Page		page;
 	BTPageOpaque opaque;
 	OffsetNumber maxoffset;
+	nbts_prep_ctx(NULL);
 
 	page = palloc(BLCKSZ);
 
@@ -3141,6 +3147,7 @@ static inline BTScanInsert
 bt_mkscankey_pivotsearch(Relation rel, IndexTuple itup)
 {
 	BTScanInsert skey;
+	nbts_prep_ctx(NULL);
 
 	skey = _bt_mkscankey(rel, itup);
 	skey->pivotsearch = true;
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 4d7fa5aff4..4b11ea9ad7 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -940,8 +940,9 @@ and for each step in the binary search (that does not compare less than the
 insert key) improve the equal-prefix bounds.
 
 Using the above optimization, we now (on average) only need 2 full key
-compares per page, as opposed to ceil(log2(ntupsperpage)) + 1; a significant
-improvement.
+compares per page (plus ceil(log2(ntupsperpage)) single-attribute compares),
+as opposed to the ceil(log2(ntupsperpage)) + 1 of a naive implementation;
+a significant improvement.
 
 Notes about deduplication
 -------------------------
@@ -1083,6 +1084,34 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+Notes about nbtree specialization
+---------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes
+with variable length attributes, due to our inability to cache the offset
+of each attribute into an on-disk tuple. To combat this, we'd have to either
+fully deserialize the tuple, or maintain our offset into the tuple as we
+iterate over the tuple's fields.
+
+Keeping track of this offset also has a non-negligible overhead too, so we'd
+prefer to not have to keep track of these offsets when we can use the cache.
+By specializing performance-sensitive search functions for these specific
+index tuple shapes and calling those selectively, we can keep the performance
+of cacheable attribute offsets where that is applicable, while improving
+performance where we currently would see O(n_atts^2) time iterating on
+variable-length attributes.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also the default path, and is comparatively slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 0349988cf5..4589ade267 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,260 +22,14 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
-			   Size newitemsz, bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple and add it to our temp page (newpage).
-			 * Else add pending interval's base tuple to the temp page as-is.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place, when this page's newly allocated right sibling page
-				 * gets its first deduplication pass).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -316,6 +70,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 	TM_IndexDeleteOp delstate;
 	bool		neverdedup;
 	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	nbts_prep_ctx(rel);
 
 	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
 	newitemsz += sizeof(ItemIdData);
@@ -752,55 +507,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
new file mode 100644
index 0000000000..584211fe66
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -0,0 +1,317 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtdedup_spec.c
+ *	  Index shape-specialized functions for nbtdedup.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtdedup_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_do_singleval NBTS_FUNCTION(_bt_do_singleval)
+
+static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
+							 OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
+			   Size newitemsz, bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				minoff,
+				maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+				 _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple and add it to our temp page (newpage).
+			 * Else add pending interval's base tuple to the temp page as-is.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place, when this page's newly allocated right sibling page
+				 * gets its first deduplication pass).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+_bt_do_singleval(Relation rel, Page page, BTDedupState state,
+				 OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 4c3bdefae2..ca8ea60ffb 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,17 +30,10 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
 static void _bt_stepright(Relation rel, BTInsertState insertstate, BTStack stack);
 static void _bt_insertonpg(Relation rel, BTScanInsert itup_key,
 						   Buffer buf,
@@ -73,313 +66,8 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
-					   itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-			AttrNumber	cmpcol = 1;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
-							&cmpcol) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
-
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
-					  NULL);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -423,6 +111,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	bool		inposting = false;
 	bool		prevalldead = true;
 	int			curposti = 0;
+	nbts_prep_ctx(rel);
 
 	/* Assume unique until we find a duplicate */
 	*is_unique = true;
@@ -774,253 +463,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				AttrNumber	cmpcol = 1;
-
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
-					break;
-
-				_bt_stepright(rel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			AttrNumber	cmpcol = 1;
-
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	{
-		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
-		Assert(P_RIGHTMOST(opaque) ||
-			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
-	}
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1501,6 +943,7 @@ _bt_split(Relation rel, BTScanInsert itup_key, Buffer buf, Buffer cbuf,
 	bool		newitemonleft,
 				isleaf,
 				isrightmost;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * origpage is the original page to be split.  leftpage is a temporary
@@ -2693,6 +2136,7 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 	BTScanInsert itup_key = insertstate->itup_key;
 	Page		page = BufferGetPage(buffer);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
+	nbts_prep_ctx(rel);
 
 	Assert(P_ISLEAF(opaque));
 	Assert(simpleonly || itup_key->heapkeyspace);
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
new file mode 100644
index 0000000000..d37afae5ae
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -0,0 +1,583 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtinsert_spec.c
+ *	  Index shape-specialized functions for nbtinsert.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtinsert_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_search_insert NBTS_FUNCTION(_bt_search_insert)
+#define _bt_findinsertloc NBTS_FUNCTION(_bt_findinsertloc)
+
+static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
+static OffsetNumber _bt_findinsertloc(Relation rel,
+									  BTInsertState insertstate,
+									  bool checkingunique,
+									  bool indexUnchanged,
+									  BTStack stack,
+									  Relation heapRel);
+
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+_bt_doinsert(Relation rel, IndexTuple itup,
+			 IndexUniqueCheck checkUnique, bool indexUnchanged,
+			 Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = _bt_mkscankey(rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = _bt_search_insert(rel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
+									   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
+					   itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+_bt_search_insert(Relation rel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
+					  NULL);
+}
+
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+_bt_findinsertloc(Relation rel,
+				  BTInsertState insertstate,
+				  bool checkingunique,
+				  bool indexUnchanged,
+				  BTStack stack,
+				  Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				AttrNumber	cmpcol = 1;
+
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
+					break;
+
+				_bt_stepright(rel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			AttrNumber	cmpcol = 1;
+
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
+
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 3feee28d19..7710226f41 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1819,6 +1819,7 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 	bool		rightsib_empty;
 	Page		page;
 	BTPageOpaque opaque;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Save original leafbuf block number from caller.  Only deleted blocks
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 1cc88da032..ceeafd637f 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,8 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -120,7 +122,7 @@ bthandler(PG_FUNCTION_ARGS)
 
 	amroutine->ambuild = btbuild;
 	amroutine->ambuildempty = btbuildempty;
-	amroutine->aminsert = btinsert;
+	amroutine->aminsert = btinsert_default;
 	amroutine->ambulkdelete = btbulkdelete;
 	amroutine->amvacuumcleanup = btvacuumcleanup;
 	amroutine->amcanreturn = btcanreturn;
@@ -152,6 +154,8 @@ btbuildempty(Relation index)
 {
 	Page		metapage;
 
+	nbt_opt_specialize(index);
+
 	/* Construct metapage. */
 	metapage = (Page) palloc(BLCKSZ);
 	_bt_initmetapage(metapage, P_NONE, 0, _bt_allequalimage(index, false));
@@ -177,33 +181,6 @@ btbuildempty(Relation index)
 	smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
@@ -345,6 +322,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -788,6 +767,8 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
 
+	nbt_opt_specialize(rel);
+
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
 		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
new file mode 100644
index 0000000000..6b766581ab
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -0,0 +1,69 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_spec.c
+ *	  Index shape-specialized functions for nbtree.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtree_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+_bt_specialize(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	NBTS_MAKE_CTX(rel);
+	/*
+	 * We can't directly address _bt_specialize here because it'd be macro-
+	 * expanded, nor can we utilize NBTS_SPECIALIZE_NAME here because it'd
+	 * try to call _bt_specialize, which would be an infinite recursive call.
+	 */
+	switch (__nbts_ctx) {
+		case NBTS_CTX_CACHED:
+			_bt_specialize_cached(rel);
+			break;
+		case NBTS_CTX_DEFAULT:
+			break;
+	}
+#else
+	rel->rd_indam->aminsert = btinsert;
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+btinsert(Relation rel, Datum *values, bool *isnull,
+		 ItemPointer ht_ctid, Relation heapRel,
+		 IndexUniqueCheck checkUnique,
+		 bool indexUnchanged,
+		 IndexInfo *indexInfo)
+{
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index e3b828137b..0089fe7eeb 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,12 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
-								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -47,6 +43,8 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -71,572 +69,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- */
-BTStack
-_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
-		   Snapshot snapshot)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-	char		tupdatabuf[BLCKSZ / 3];
-	AttrNumber	highkeycmpcol = 1;
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot, &highkeycmpcol,
-							  (char *) tupdatabuf);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
-		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		highkeycmpcol = 1;
-
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split
- * is completed.  'stack' is only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  Snapshot snapshot,
-			  AttrNumber *comparecol,
-			  char *tupdatabuf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		AttrNumber	cmpcol = 1;
-
-		page = BufferGetPage(buf);
-		TestForOldSnapshot(snapshot, rel, page);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-		{
-			*comparecol = 1;
-			break;
-		}
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		/*
-		 * tupdatabuf is filled with the right seperator of the parent node.
-		 * This allows us to do a binary equality check between the parent
-		 * node's right seperator (which is < key) and this page's P_HIKEY.
-		 * If they equal, we can reuse the result of the parent node's
-		 * rightkey compare, which means we can potentially save a full key
-		 * compare (which includes indirect calls to attribute comparison
-		 * functions).
-		 * 
-		 * Without this, we'd on average use 3 full key compares per page before
-		 * we achieve full dynamic prefix bounds, but with this optimization
-		 * that is only 2.
-		 * 
-		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
-		 * we move right in the binary search on the page, this average equals
-		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
-		 */
-		if (!P_IGNORE(opaque) && *comparecol > 1)
-		{
-			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
-			IndexTuple buftuple = (IndexTuple) tupdatabuf;
-			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
-			{
-				char *dataptr = (char *) itup;
-
-				if (memcmp(dataptr + sizeof(IndexTupleData),
-						   tupdatabuf + sizeof(IndexTupleData),
-						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
-					break;
-			} else {
-				*comparecol = 1;
-			}
-		} else {
-			*comparecol = 1;
-		}
-
-		if (P_IGNORE(opaque) ||
-				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
-		{
-			*comparecol = 1;
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-		{
-			*comparecol = cmpcol;
-			break;
-		}
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf,
-			AttrNumber *highkeycmpcol)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-	AttrNumber	highcmpcol = *highkeycmpcol,
-				lowcmpcol = 1;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-		}
-	}
-	
-	*highkeycmpcol = highcmpcol;
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-				   AttrNumber highcmpcol)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-	AttrNumber	lowcmpcol = 1;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
-
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
  *
@@ -704,228 +136,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum,
-			AttrNumber *comparecol)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-
-	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-		{
-			*comparecol = i;
-			return result;
-		}
-
-		scankey++;
-	}
-
-	/*
-	 * All tuple attributes are equal to the scan key, only later attributes
-	 * could potentially not equal the scan key.
-	 */
-	*comparecol = ntupatts + 1;
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -967,6 +177,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(rel);
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1589,280 +800,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2071,12 +1008,11 @@ static bool
 _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 {
 	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Relation	rel;
+	Relation	rel = scan->indexRelation;
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
-
-	rel = scan->indexRelation;
+	nbts_prep_ctx(rel);
 
 	if (ScanDirectionIsForward(dir))
 	{
@@ -2488,6 +1424,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	BTPageOpaque opaque;
 	OffsetNumber start;
 	BTScanPosItem *currItem;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Scan down to the leftmost or rightmost leaf page.  This is a simplified
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
new file mode 100644
index 0000000000..37cc3647d3
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -0,0 +1,1087 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsearch_spec.c
+ *	  Index shape-specialized functions for nbtsearch.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsearch_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_binsrch		NBTS_FUNCTION(_bt_binsrch)
+#define _bt_readpage	NBTS_FUNCTION(_bt_readpage)
+
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
+static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
+						 OffsetNumber offnum);
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ */
+BTStack
+_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
+		   Snapshot snapshot)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
+							  page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		highkeycmpcol = 1;
+
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split
+ * is completed.  'stack' is only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ */
+Buffer
+_bt_moveright(Relation rel,
+			  BTScanInsert key,
+			  Buffer buf,
+			  bool forupdate,
+			  BTStack stack,
+			  int access,
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		AttrNumber	cmpcol = 1;
+
+		page = BufferGetPage(buf);
+		TestForOldSnapshot(snapshot, rel, page);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
+			break;
+		}
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+			_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
+		{
+			*comparecol = 1;
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+		{
+			*comparecol = cmpcol;
+			break;
+		}
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+_bt_binsrch(Relation rel,
+			BTScanInsert key,
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+		}
+	}
+
+	*highkeycmpcol = highcmpcol;
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+	AttrNumber	lowcmpcol = 1;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+_bt_compare(Relation rel,
+			BTScanInsert key,
+			Page page,
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+		{
+			*comparecol = i;
+			return result;
+		}
+
+		scankey++;
+	}
+
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 67b7b1710c..af408f704f 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,8 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -544,6 +544,7 @@ static void
 _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 {
 	BTWriteState wstate;
+	nbts_prep_ctx(btspool->index);
 
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
@@ -844,6 +845,7 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 	Size		pgspc;
 	Size		itupsz;
 	bool		isleaf;
+	nbts_prep_ctx(wstate->index);
 
 	/*
 	 * This is a handy place to check for cancel interrupts during the btree
@@ -1176,264 +1178,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			Assert(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
new file mode 100644
index 0000000000..368d6f244c
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -0,0 +1,280 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsort_spec.c
+ *	  Index shape-specialized functions for nbtsort.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsort_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_load NBTS_FUNCTION(_bt_load)
+
+static void _bt_load(BTWriteState *wstate,
+					 BTSpool *btspool, BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			Assert(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
+										 itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index ecb49bb471..991118fd50 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -639,6 +639,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	ItemId		itemid;
 	IndexTuple	tup;
 	int			keepnatts;
+	nbts_prep_ctx(state->rel);
 
 	Assert(state->is_leaf && !state->is_rightmost);
 
@@ -945,6 +946,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 			   *rightinterval;
 	int			perfectpenalty;
 	int			indnkeyatts = IndexRelationGetNumberOfKeyAttributes(state->rel);
+	nbts_prep_ctx(state->rel);
 
 	/* Assume that alternative strategy won't be used for now */
 	*strategy = SPLIT_DEFAULT;
@@ -1137,6 +1139,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 {
 	IndexTuple	lastleft;
 	IndexTuple	firstright;
+	nbts_prep_ctx(state->rel);
 
 	if (!state->is_leaf)
 	{
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 8003583c0a..85f92adda8 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,10 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.c"
+#include "access/nbtree_spec.h"
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1220,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1703,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
new file mode 100644
index 0000000000..0288da22d6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -0,0 +1,775 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtutils_spec.c
+ *	  Index shape-specialized functions for nbtutils.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtutils_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_check_rowcompare	NBTS_FUNCTION(_bt_check_rowcompare)
+#define _bt_keep_natts			NBTS_FUNCTION(_bt_keep_natts)
+
+static bool _bt_check_rowcompare(ScanKey skey,
+								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+								 ScanDirection dir, bool *continuescan);
+static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
+							 IndexTuple firstright, BTScanInsert itup_key);
+
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+_bt_mkscankey(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+			  ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
+									 continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
+					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			 BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			   BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index eb6cfcfd00..12f909e1cf 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -57,8 +57,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int tuplen);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static void writetup_index(Tuplesortstate *state, LogicalTape *tape,
@@ -130,6 +128,9 @@ typedef struct
 	int			datumTypeLen;
 } TuplesortDatumArg;
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesortvariants_spec.c"
+#include "access/nbtree_spec.h"
+
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
 					 int nkeys, AttrNumber *attNums,
@@ -217,6 +218,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 	MemoryContext oldcontext;
 	TuplesortClusterArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	Assert(indexRel->rd_rel->relam == BTREE_AM_OID);
 
@@ -328,6 +330,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	TuplesortIndexBTreeArg *arg;
 	MemoryContext oldcontext;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -461,6 +464,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 	MemoryContext oldcontext;
 	TuplesortIndexBTreeArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -1259,142 +1263,6 @@ removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
 	}
 }
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
-	SortSupport sortKey = base->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = base->nKeys;
-	tupDes = RelationGetDescr(arg->index.indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(arg->index.indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(arg->index.heapRel,
-									RelationGetRelationName(arg->index.indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
new file mode 100644
index 0000000000..0791f41136
--- /dev/null
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -0,0 +1,158 @@
+/*-------------------------------------------------------------------------
+ *
+ * tuplesortvariants_spec.c
+ *	  Index shape-specialized functions for tuplesortvariants.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/tuplesortvariants_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define comparetup_index_btree NBTS_FUNCTION(comparetup_index_btree)
+
+static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+								   Tuplesortstate *state);
+
+static int
+comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+					   Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
+	SortSupport sortKey = base->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	Datum		datum1,
+				datum2;
+	bool		isnull1,
+				isnull2;
+
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = base->nKeys;
+	tupDes = RelationGetDescr(arg->index.indexRel);
+
+	if (sortKey->abbrev_converter)
+	{
+		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
+
+		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
+												datum2, isnull2,
+												sortKey);
+		if (compare != 0)
+			return compare;
+	}
+
+	/* they are equal, so we only need to examine one null flag */
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	sortKey++;
+	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	{
+		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+
+		compare = ApplySortComparator(datum1, isnull1,
+									  datum2, isnull2,
+									  sortKey);
+		if (compare != 0)
+			return compare;		/* done when we find unequal attributes */
+
+		/* they are equal, so we only need to examine one null flag */
+		if (isnull1)
+			equal_hasnull = true;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(arg->index.indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(arg->index.heapRel,
+									   RelationGetRelationName(arg->index.indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 4cb24fa005..f3f0961052 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1122,15 +1122,27 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+typedef enum NBTS_CTX {
+	NBTS_CTX_CACHED, 
+	NBTS_CTX_DEFAULT, /* fallback */
+} NBTS_CTX;
+
+static inline NBTS_CTX _nbt_spec_context(Relation irel)
+{
+	if (!PointerIsValid(irel))
+		return NBTS_CTX_DEFAULT;
+
+	return NBTS_CTX_CACHED;
+}
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
+#include "nbtree_spec.h"
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1161,9 +1173,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
-						   IndexTuple newitem, Size newitemsz,
-						   bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1179,9 +1188,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Buffer lbuf, BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, BTStack stack, BlockNumber child);
 
@@ -1229,16 +1235,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
-						  int access, Snapshot snapshot);
-extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access,
-							Snapshot snapshot, AttrNumber *comparecol,
-							char *tupdatabuf);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-									   AttrNumber highcmpcol);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
-						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
@@ -1247,7 +1243,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1255,8 +1250,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1269,10 +1262,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
new file mode 100644
index 0000000000..0bfb623f37
--- /dev/null
+++ b/src/include/access/nbtree_spec.h
@@ -0,0 +1,180 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ * - nbts_context(irel)
+ *   Constructs a context that is used to call specialized functions.
+ *   Note that this is optional in paths that are inaccessible to unspecialized
+ *   code paths, but should be included in NBTS_BUILD_GENERIC.
+ */
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+#define NBTS_CTX_NAME __nbts_ctx
+
+/* contextual specializations */
+#define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
+#define NBTS_SPECIALIZE_NAME(name) ( \
+	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	) \
+)
+
+/* how do we make names? */
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define nbt_opt_specialize(rel) \
+do { \
+	Assert(PointerIsValid(rel)); \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
+	{ \
+		nbts_prep_ctx(rel); \
+		_bt_specialize(rel); \
+	} \
+} while (false)
+
+/*
+ * Access a specialized nbtree function, based on the shape of the index key.
+ */
+#define NBTS_DEFINITIONS
+
+/*
+ * Call a potentially specialized function for a given btree operation.
+ *
+ * NB: the rel argument is evaluated multiple times.
+ */
+#ifdef NBTS_FUNCTION
+#undef NBTS_FUNCTION
+#endif
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+/* While specializing, the context is the local context */
+#ifdef nbts_prep_ctx
+#undef nbts_prep_ctx
+#endif
+#define nbts_prep_ctx(rel)
+
+/*
+ * Specialization 1: CACHED
+ *
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_SPECIALIZING_CACHED
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * Specialization 2: DEFAULT
+ *
+ * "Default", externally accessible, not so much optimized functions
+ */
+
+/* the default context (and later contexts) do need to specialize, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * from here on all NBTS_FUNCTIONs are from specialized function names that
+ * are being called. Change the result of those macros from a direct call
+ * call to a conditional call to the right place, depending on the correct
+ * context.
+ */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) NBTS_SPECIALIZE_NAME(name)
+
+#undef NBT_SPECIALIZE_FILE
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
new file mode 100644
index 0000000000..ac60319eff
--- /dev/null
+++ b/src/include/access/nbtree_specfuncs.h
@@ -0,0 +1,66 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+#define _bt_specialize		NBTS_FUNCTION(_bt_specialize)
+#define btinsert			NBTS_FUNCTION(btinsert)
+#define _bt_dedup_pass		NBTS_FUNCTION(_bt_dedup_pass)
+#define _bt_doinsert		NBTS_FUNCTION(_bt_doinsert)
+#define _bt_search			NBTS_FUNCTION(_bt_search)
+#define _bt_moveright		NBTS_FUNCTION(_bt_moveright)
+#define _bt_binsrch_insert	NBTS_FUNCTION(_bt_binsrch_insert)
+#define _bt_compare			NBTS_FUNCTION(_bt_compare)
+#define _bt_mkscankey		NBTS_FUNCTION(_bt_mkscankey)
+#define _bt_checkkeys		NBTS_FUNCTION(_bt_checkkeys)
+#define _bt_truncate		NBTS_FUNCTION(_bt_truncate)
+#define _bt_keep_natts_fast	NBTS_FUNCTION(_bt_keep_natts_fast)
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void _bt_specialize(Relation rel);
+
+extern bool btinsert(Relation rel, Datum *values, bool *isnull,
+					 ItemPointer ht_ctid, Relation heapRel,
+					 IndexUniqueCheck checkUnique, bool indexUnchanged,
+					 struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
+						   IndexTuple newitem, Size newitemsz,
+						   bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool _bt_doinsert(Relation rel, IndexTuple itup,
+						 IndexUniqueCheck checkUnique, bool indexUnchanged,
+						 Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
+						  int access, Snapshot snapshot);
+extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
+							bool forupdate, BTStack stack, int access,
+							Snapshot snapshot, AttrNumber *comparecol,
+							char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
+extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+						  ScanDirection dir, bool *continuescan);
+extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright, BTScanInsert itup_key);
+extern int _bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright);
-- 
2.39.0

From ea88f2340887d7ae984b0a96664f7667bc8db50a Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 13 Jan 2023 15:42:41 +0100
Subject: [PATCH v9 6/6] btree specialization for variable-length
 multi-attribute keys

The default code path is relatively slow at O(n^2), so with multiple
attributes we accept the increased startup cost in favour of lower
costs for later attributes.

Note that this will only be used for indexes that use at least one
variable-length key attribute (except as last key attribute in specific
cases).
---
 src/backend/access/nbtree/README        |  10 +-
 src/backend/access/nbtree/nbtree_spec.c |   3 +
 src/include/access/itup_attiter.h       | 199 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  11 +-
 src/include/access/nbtree_spec.h        |  48 +++++-
 5 files changed, 260 insertions(+), 11 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 6864902637..2219c58242 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1104,15 +1104,13 @@ in the index AM to call the specialized functions, increasing the
 performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
- - indexes with only a single key attribute
- - multi-column indexes that could benefit from the attcacheoff optimization
+ - indexes with only a single key attribute,
+ - multi-column indexes that cannot pre-calculate the offsets of all key
+   attributes in the tuple data section,
+ - multi-column indexes that do benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
 
-Future work will optimize for multi-column indexes that don't benefit
-from the attcacheoff optimization by improving on the O(n^2) nature of
-index_getattr through storing attribute offsets.
-
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 21635397ed..699197dfa7 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_UNCACHED:
+			_bt_specialize_uncached(rel);
+			break;
 		case NBTS_CTX_SINGLE_KEYATT:
 			_bt_specialize_single_keyatt(rel);
 			break;
diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..c8fb6954bc
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,199 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup_attiter.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+#include "varatt.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 4628c41e9a..d5ed38bb71 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1124,18 +1125,26 @@ typedef struct BTOptions
 
 typedef enum NBTS_CTX {
 	NBTS_CTX_SINGLE_KEYATT, 
+	NBTS_CTX_UNCACHED,
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	AttrNumber	nKeyAtts;
+
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
-	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+	nKeyAtts = IndexRelationGetNumberOfKeyAttributes(irel);
+
+	if (nKeyAtts == 1)
 		return NBTS_CTX_SINGLE_KEYATT;
 
+	if (TupleDescAttr(irel->rd_att, nKeyAtts - 1)->attcacheoff < -1)
+		return NBTS_CTX_UNCACHED;
+
 	return NBTS_CTX_CACHED;
 }
 
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 3ad64aad39..a57d69f588 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -44,6 +44,7 @@
  * Macros used in the nbtree specialization code.
  */
 #define NBTS_TYPE_SINGLE_KEYATT single_keyatt
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -52,8 +53,10 @@
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
 	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
-		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		(NBTS_CTX_NAME) == NBTS_CTX_UNCACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED)) : ( \
+			(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+				NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+			) \
 		) \
 	) \
 )
@@ -68,9 +71,12 @@ do { \
 	Assert(PointerIsValid(rel)); \
 	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
 	{ \
-		nbts_prep_ctx(rel); \
 		Assert(PointerIsValid(rel)); \
-		_bt_specialize(rel); \
+		PopulateTupleDescCacheOffsets(rel->rd_att); \
+		{ \
+			nbts_prep_ctx(rel); \
+			_bt_specialize(rel); \
+		} \
 	} \
 } while (false)
 
@@ -216,6 +222,40 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All subsequent contexts are from non-templated code, so
  * they need to actually include the context.
-- 
2.39.0

From e8d891adb0f4bdcf091edc5e02155303503ba603 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 20:04:56 +0100
Subject: [PATCH v10 4/6] Optimize nbts_attiter for nkeyatts==1 btrees

This removes the index_getattr_nocache call path, which has significant overhead, and uses constant 0 offset.
---
 src/backend/access/nbtree/README        |  1 +
 src/backend/access/nbtree/nbtree_spec.c |  3 ++
 src/include/access/nbtree.h             | 35 ++++++++++++++++
 src/include/access/nbtree_spec.h        | 56 ++++++++++++++++++++++++-
 4 files changed, 93 insertions(+), 2 deletions(-)

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 4b11ea9ad7..6864902637 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1104,6 +1104,7 @@ in the index AM to call the specialized functions, increasing the
 performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
+ - indexes with only a single key attribute
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 6b766581ab..21635397ed 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_SINGLE_KEYATT:
+			_bt_specialize_single_keyatt(rel);
+			break;
 		case NBTS_CTX_DEFAULT:
 			break;
 	}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index f3f0961052..4628c41e9a 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1123,6 +1123,7 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
 typedef enum NBTS_CTX {
+	NBTS_CTX_SINGLE_KEYATT, 
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
@@ -1132,9 +1133,43 @@ static inline NBTS_CTX _nbt_spec_context(Relation irel)
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
+	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+		return NBTS_CTX_SINGLE_KEYATT;
+
 	return NBTS_CTX_CACHED;
 }
 
+static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
+									bool *isNull)
+{
+	Datum	result;
+	if (IndexTupleHasNulls(tuple))
+	{
+		if (att_isnull(0, (bits8 *)(tuple) + sizeof(IndexTupleData)))
+		{
+			*isNull = true;
+			result = (Datum) 0;
+		}
+		else
+		{
+			*isNull = false;
+			result = fetchatt(TupleDescAttr(tupleDesc, 0),
+							  ((char *) tuple)
+							  + MAXALIGN(sizeof(IndexTupleData)
+							  + sizeof(IndexAttributeBitMapData)));
+		}
+	}
+	else
+	{
+		*isNull = false;
+		result = fetchatt(TupleDescAttr(tupleDesc, 0),
+						  ((char *) tuple)
+						  + MAXALIGN(sizeof(IndexTupleData)));
+	}
+
+	return result;
+}
+
 
 #define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
 #include "nbtree_spec.h"
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index fa38b09c6e..8e476c300d 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -44,6 +44,7 @@
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_KEYATT single_keyatt
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -51,8 +52,10 @@
 /* contextual specializations */
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
-	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
+		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		) \
 	) \
 )
 
@@ -164,6 +167,55 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 3: SINGLE_KEYATT
+ *
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path cannot be used for indexes with multiple key
++ *  columns, because it never considers the next column.
+ */
+
+/* the default context (and later contexts) do need to specialize, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel)
+
+#define NBTS_SPECIALIZING_SINGLE_KEYATT
+#define NBTS_TYPE NBTS_TYPE_SINGLE_KEYATT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	_bt_getfirstatt(itup, tupDesc, &NBTS_MAKE_NAME(itup, isNull)) \
+)
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_KEYATT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All next uses of nbts_prep_ctx are in non-templated code, so here we make
  * sure we actually create the context.
-- 
2.39.0

From 5a0733796abf607c44f366f066fe6bf99c3118b5 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 12 Jan 2023 21:34:36 +0100
Subject: [PATCH v10 5/6] Add an attcacheoff-populating function

It populates attcacheoff-capable attributes with the correct offset,
and fills attributes whose offset is uncacheable with an 'uncacheable'
indicator value; as opposed to -1 which signals "unknown".

This allows users of the API to remove redundant cycles that try to
cache the offset of attributes - instead of O(N-attrs) operations, this
one only requires a O(1) check.
---
 src/backend/access/common/tupdesc.c | 111 ++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |   2 +
 2 files changed, 113 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 72a2c3d3db..f2d80ed0db 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -919,3 +919,114 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid offset value.
+ *
+ * Populates attcacheoff with a negative cache value when no offset
+ * can be calculated (due to e.g. variable length attributes).
+ * The negative value is a value relative to the last cacheable attribute
+ *   attcacheoff = -1 - (thisattno - cachedattno)
+ * so that the last attribute with cached offset can be found with
+ *   cachedattno = attcacheoff + 1 + thisattno
+ *   
+ * The value returned is the AttrNumber of the last (1-based) attribute that
+ * had its offset cached.
+ * 
+ * When the TupleDesc has 0 attributes, it returns 0.
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	currAttNo, lastCachedAttNo;
+
+	if (numberOfAttributes == 0)
+		return 0;
+
+	/* Non-negative value: this attribute is cached */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff >= 0)
+		return (AttrNumber) desc->natts;
+	/*
+	 * Attribute has been filled with relative offset to last cached value, but
+	 * it itself is unreachable.
+	 */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+		return (AttrNumber) (TupleDescAttr(desc, desc->natts - 1)->attcacheoff + 1 + desc->natts);
+
+	/* last attribute of the tupledesc may or may not support attcacheoff */
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	currAttNo = 1;
+	/*
+	 * Other code may have populated the value previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (currAttNo < numberOfAttributes &&
+		   TupleDescAttr(desc, currAttNo)->attcacheoff >= 0)
+		currAttNo++;
+
+	/*
+	 * Cache offset is undetermined. Start calculating offsets if possible.
+	 * 
+	 * When we exit this block, currAttNo will point at the first uncacheable
+	 * attribute, or past the end of the attribute array.
+	 */
+	if (currAttNo < numberOfAttributes &&
+		TupleDescAttr(desc, currAttNo)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, currAttNo - 1);
+		int32 off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (currAttNo < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, currAttNo);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+					{
+						att->attcacheoff = off;
+						currAttNo++;
+					}
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				currAttNo++;
+			}
+		}
+	}
+
+	Assert(currAttNo == numberOfAttributes || (
+		currAttNo < numberOfAttributes
+		&& TupleDescAttr(desc, (currAttNo - 1))->attcacheoff >= 0
+		&& TupleDescAttr(desc, currAttNo)->attcacheoff == -1
+	));
+	/*
+	 * No cacheable offsets left. Fill the rest with negative cache values,
+	 * but return the latest cached offset.
+	 */
+	lastCachedAttNo = currAttNo;
+
+	while (currAttNo < numberOfAttributes)
+	{
+		TupleDescAttr(desc, currAttNo)->attcacheoff = -1 - (currAttNo - lastCachedAttNo);
+		currAttNo++;
+	}
+
+	return lastCachedAttNo;
+}
\ No newline at end of file
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index b4286cf922..2673f2d0f3 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.39.0

From 8b848f7bc63bb3999308940593abba10208c3913 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:57:21 +0100
Subject: [PATCH v10 3/6] Use specialized attribute iterators in the
 specialized source files

This is committed separately to make clear what substantial changes were
made to the pre-existing code.

Even though not all nbt*_spec functions have been updated; these functions
can now directly call (and inline, and optimize for) the specialized functions
they call, instead of having to determine the right specialization based on
the (potentially locally unavailable) index relation, making the specialization
of those functions still worth specializing/duplicating.
---
 src/backend/access/nbtree/nbtsearch_spec.c    | 18 +++---
 src/backend/access/nbtree/nbtsort_spec.c      | 24 +++----
 src/backend/access/nbtree/nbtutils_spec.c     | 62 ++++++++++++-------
 .../utils/sort/tuplesortvariants_spec.c       | 54 +++++++++-------
 4 files changed, 92 insertions(+), 66 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index 37cc3647d3..4ce39e7724 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -632,6 +632,7 @@ _bt_compare(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -664,23 +665,26 @@ _bt_compare(Relation rel,
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 
 	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
@@ -709,7 +713,7 @@ _bt_compare(Relation rel,
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
 		{
-			*comparecol = i;
+			*comparecol = nbts_attiter_attnum;
 			return result;
 		}
 
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index 368d6f244c..6f33cc4cc2 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -34,8 +34,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -57,7 +56,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -90,21 +89,24 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 			else if (itup != NULL)
 			{
 				int32		compare = 0;
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index 0288da22d6..07ca18f404 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -64,7 +64,7 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -95,7 +95,10 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -106,27 +109,30 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -675,6 +681,8 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -686,20 +694,22 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -707,6 +717,7 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -747,24 +758,27 @@ _bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 0791f41136..61c4826853 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -40,11 +40,8 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 	bool		equal_hasnull = false;
 	int			nkey;
 	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
 
 	/* Compare the leading sort key */
 	compare = ApplySortComparator(a->datum1, a->isnull1,
@@ -59,37 +56,46 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 	keysz = base->nKeys;
 	tupDes = RelationGetDescr(arg->index.indexRel);
 
-	if (sortKey->abbrev_converter)
+	if (!sortKey->abbrev_converter)
 	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
+		nkey = 2;
+		sortKey++;
+	}
+	else
+	{
+		nkey = 1;
 	}
 
 	/* they are equal, so we only need to examine one null flag */
 	if (a->isnull1)
 		equal_hasnull = true;
 
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
 	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+		Datum	datum1,
+				datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		else
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
 
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
 		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
+			return compare;
 
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
+		if (nbts_attiter_curattisnull(tuple1))
 			equal_hasnull = true;
+
+		sortKey++;
 	}
 
 	/*
-- 
2.39.0

From 9cca2dce4f968994e989e7214366600f5d0f6c5e Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Tue, 10 Jan 2023 21:45:44 +0100
Subject: [PATCH v10 1/6] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also have those prefixing attributes that equal the
scankey.

We cannot generally propagate this information to _binsrch on
lower pages, as this downstream page may have concurrently split
and/or have merged with its deleted left neighbour (see [0]),
which moves the keyspace of the linked page. We thus can only
trust the current state of this current page for this optimization,
which means we must validate this state each time we open the page.

Although this limits the overall applicability of the
performance improvement, it still allows for a nice performance
improvement in most cases where initial columns have many
duplicate values and a compare function that is not cheap.

As an exception to the above rule, most of the time a pages'
highkey is equal to the right seperator on the parent page due to
how btree splits are done. By storing this right seperator from
the parent page and then validating that the highkey of the child
page contains the exact same data, we can restore the right prefix
bound without having to call the relatively expensive _bt_compare.

In the worst-case scenario of a concurrent page split, we'd still
have to validate the full key, but that doesn't happen very often
when compared to the number of times we descend the btree.
---
 contrib/amcheck/verify_nbtree.c       |  17 ++--
 src/backend/access/nbtree/README      |  43 ++++++++++
 src/backend/access/nbtree/nbtinsert.c |  34 +++++---
 src/backend/access/nbtree/nbtsearch.c | 119 +++++++++++++++++++++++---
 src/include/access/nbtree.h           |  10 ++-
 5 files changed, 189 insertions(+), 34 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 257cff671b..22bb229820 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2701,6 +2701,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2710,13 +2711,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2778,6 +2779,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2788,7 +2790,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2840,10 +2842,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2863,10 +2866,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2901,13 +2905,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index dd0f7ad2bd..16a31d2bfe 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,49 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+saving the indirect function calls in the compare operation.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by a parent page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. [2,3) to [1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+There is positive news, though: A page split will put a binary copy of the
+page's highkey in the parent page. This means that we usually can reuse
+the compare result of the parent page's downlink's right sibling when we
+discover that their representation is binary equal. In general this will
+be the case, as only in concurrent page splits and deletes the downlink
+may not point to the page with the correct highkey bound (_bt_moveright
+only rarely actually moves right).
+
+To implement this, we copy the downlink's right differentiator key into a
+temporary buffer, which is then compared against the child pages' highkey.
+If they match, we reuse the compare result (plus prefix) we had for it from
+the parent page, if not, we need to do a full _bt_compare. Because memcpy +
+memcmp is cheap compared to _bt_compare, and because it's quite unlikely
+that we guess wrong this speeds up our _bt_moveright code (at cost of some
+stack memory in _bt_search and some overhead in case of a wrong prediction)
+
+Now that we have prefix bounds on the highest value of a page, the
+_bt_binsrch procedure will use this result as a rightmost prefix compare,
+and for each step in the binary search (that does not compare less than the
+insert key) improve the equal-prefix bounds.
+
+Using the above optimization, we now (on average) only need 2 full key
+compares per page (plus ceil(log2(ntupsperpage)) single-attribute compares),
+as opposed to the ceil(log2(ntupsperpage)) + 1 of a naive implementation;
+a significant improvement.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index f4c1a974ef..4c3bdefae2 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -326,6 +326,7 @@ _bt_search_insert(Relation rel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -344,7 +345,8 @@ _bt_search_insert(Relation rel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -438,7 +440,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = _bt_binsrch_insert(rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -448,6 +450,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -483,7 +487,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(_bt_compare(rel, itup_key, page, offset, &cmpcol) < 0);
 				break;
 			}
 
@@ -508,7 +512,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (_bt_compare(rel, itup_key, page, offset, &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -718,11 +722,12 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -865,6 +870,8 @@ _bt_findinsertloc(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
+
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -882,7 +889,7 @@ _bt_findinsertloc(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, insertstate, stack);
@@ -935,6 +942,8 @@ _bt_findinsertloc(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
+
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -965,7 +974,7 @@ _bt_findinsertloc(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -980,10 +989,13 @@ _bt_findinsertloc(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -1002,7 +1014,7 @@ _bt_findinsertloc(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index c43c1a2830..e3b828137b 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,7 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
 static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
@@ -98,6 +99,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
 
 	/* Get the root page to start with */
 	*bufP = _bt_getroot(rel, access);
@@ -130,7 +133,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * opportunity to finish splits of internal pages too.
 		 */
 		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot);
+							  page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -142,12 +146,15 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -181,6 +188,8 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		highkeycmpcol = 1;
+
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -191,7 +200,7 @@ _bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
 	}
 
 	return stack_in;
@@ -239,12 +248,16 @@ _bt_moveright(Relation rel,
 			  bool forupdate,
 			  BTStack stack,
 			  int access,
-			  Snapshot snapshot)
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
+
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
 	 * this page is > the high key stored on the page, then the page has split
@@ -266,12 +279,17 @@ _bt_moveright(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -297,14 +315,55 @@ _bt_moveright(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
 		{
+			*comparecol = 1;
 			/* step right one page */
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -337,7 +396,8 @@ _bt_moveright(Relation rel,
 static OffsetNumber
 _bt_binsrch(Relation rel,
 			BTScanInsert key,
-			Buffer buf)
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -345,6 +405,8 @@ _bt_binsrch(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -386,16 +448,25 @@ _bt_binsrch(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
+	
+	*highkeycmpcol = highcmpcol;
 
 	/*
 	 * At this point we have high == low, but be careful: they could point
@@ -439,7 +510,8 @@ _bt_binsrch(Relation rel,
  * list split).
  */
 OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -449,6 +521,7 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -499,16 +572,22 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
+
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -656,7 +735,8 @@ int32
 _bt_compare(Relation rel,
 			BTScanInsert key,
 			Page page,
-			OffsetNumber offnum)
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -696,8 +776,9 @@ _bt_compare(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
 	{
 		Datum		datum;
 		bool		isNull;
@@ -741,11 +822,20 @@ _bt_compare(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = i;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
@@ -876,6 +966,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	AttrNumber	cmpcol = 1;
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1392,7 +1483,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = _bt_binsrch(rel, &inskey, buf, &cmpcol);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 8f48960f9d..4cb24fa005 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1232,9 +1232,13 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
 						  int access, Snapshot snapshot);
 extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
+							bool forupdate, BTStack stack, int access,
+							Snapshot snapshot, AttrNumber *comparecol,
+							char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
-- 
2.39.0

From f3bca667ac60de549337353553810610dfca8ace Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:13:04 +0100
Subject: [PATCH v10 2/6] Specialize nbtree functions on btree key shape.

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, and splits the code that can
benefit from attribute offset optimizations into separate files. This does
NOT yet update the code itself - it just makes the code compile cleanly.
The performance should be comparable if not the same.
---
 contrib/amcheck/verify_nbtree.c               |    7 +
 src/backend/access/nbtree/README              |   28 +
 src/backend/access/nbtree/nbtdedup.c          |  300 +----
 src/backend/access/nbtree/nbtdedup_spec.c     |  317 +++++
 src/backend/access/nbtree/nbtinsert.c         |  566 +--------
 src/backend/access/nbtree/nbtinsert_spec.c    |  583 +++++++++
 src/backend/access/nbtree/nbtpage.c           |    1 +
 src/backend/access/nbtree/nbtree.c            |   37 +-
 src/backend/access/nbtree/nbtree_spec.c       |   69 ++
 src/backend/access/nbtree/nbtsearch.c         | 1075 +---------------
 src/backend/access/nbtree/nbtsearch_spec.c    | 1087 +++++++++++++++++
 src/backend/access/nbtree/nbtsort.c           |  264 +---
 src/backend/access/nbtree/nbtsort_spec.c      |  280 +++++
 src/backend/access/nbtree/nbtsplitloc.c       |    3 +
 src/backend/access/nbtree/nbtutils.c          |  754 +-----------
 src/backend/access/nbtree/nbtutils_spec.c     |  775 ++++++++++++
 src/backend/utils/sort/tuplesortvariants.c    |  144 +--
 .../utils/sort/tuplesortvariants_spec.c       |  158 +++
 src/include/access/nbtree.h                   |   45 +-
 src/include/access/nbtree_spec.h              |  183 +++
 src/include/access/nbtree_specfuncs.h         |   66 +
 src/tools/pginclude/cpluspluscheck            |    2 +
 src/tools/pginclude/headerscheck              |    2 +
 23 files changed, 3613 insertions(+), 3133 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.c
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.c
 create mode 100644 src/backend/access/nbtree/nbtree_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.c
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.c
 create mode 100644 src/backend/utils/sort/tuplesortvariants_spec.c
 create mode 100644 src/include/access/nbtree_spec.h
 create mode 100644 src/include/access/nbtree_specfuncs.h

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 22bb229820..fb89d6ada2 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2680,6 +2680,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 	BTStack		stack;
 	Buffer		lbuf;
 	bool		exists;
+	nbts_prep_ctx(NULL);
 
 	key = _bt_mkscankey(state->rel, itup);
 	Assert(key->heapkeyspace && key->scantid != NULL);
@@ -2780,6 +2781,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2843,6 +2845,7 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2867,6 +2870,7 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2906,6 +2910,7 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2966,6 +2971,7 @@ palloc_btree_page(BtreeCheckState *state, BlockNumber blocknum)
 	Page		page;
 	BTPageOpaque opaque;
 	OffsetNumber maxoffset;
+	nbts_prep_ctx(NULL);
 
 	page = palloc(BLCKSZ);
 
@@ -3141,6 +3147,7 @@ static inline BTScanInsert
 bt_mkscankey_pivotsearch(Relation rel, IndexTuple itup)
 {
 	BTScanInsert skey;
+	nbts_prep_ctx(NULL);
 
 	skey = _bt_mkscankey(rel, itup);
 	skey->pivotsearch = true;
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 16a31d2bfe..4b11ea9ad7 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1084,6 +1084,34 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+Notes about nbtree specialization
+---------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes
+with variable length attributes, due to our inability to cache the offset
+of each attribute into an on-disk tuple. To combat this, we'd have to either
+fully deserialize the tuple, or maintain our offset into the tuple as we
+iterate over the tuple's fields.
+
+Keeping track of this offset also has a non-negligible overhead too, so we'd
+prefer to not have to keep track of these offsets when we can use the cache.
+By specializing performance-sensitive search functions for these specific
+index tuple shapes and calling those selectively, we can keep the performance
+of cacheable attribute offsets where that is applicable, while improving
+performance where we currently would see O(n_atts^2) time iterating on
+variable-length attributes.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also the default path, and is comparatively slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 0349988cf5..4589ade267 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,260 +22,14 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
-			   Size newitemsz, bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple and add it to our temp page (newpage).
-			 * Else add pending interval's base tuple to the temp page as-is.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place, when this page's newly allocated right sibling page
-				 * gets its first deduplication pass).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -316,6 +70,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 	TM_IndexDeleteOp delstate;
 	bool		neverdedup;
 	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	nbts_prep_ctx(rel);
 
 	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
 	newitemsz += sizeof(ItemIdData);
@@ -752,55 +507,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
new file mode 100644
index 0000000000..584211fe66
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -0,0 +1,317 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtdedup_spec.c
+ *	  Index shape-specialized functions for nbtdedup.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtdedup_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_do_singleval NBTS_FUNCTION(_bt_do_singleval)
+
+static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
+							 OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+_bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel, IndexTuple newitem,
+			   Size newitemsz, bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				minoff,
+				maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+				 _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple and add it to our temp page (newpage).
+			 * Else add pending interval's base tuple to the temp page as-is.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place, when this page's newly allocated right sibling page
+				 * gets its first deduplication pass).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+_bt_do_singleval(Relation rel, Page page, BTDedupState state,
+				 OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 4c3bdefae2..ca8ea60ffb 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,17 +30,10 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
 static void _bt_stepright(Relation rel, BTInsertState insertstate, BTStack stack);
 static void _bt_insertonpg(Relation rel, BTScanInsert itup_key,
 						   Buffer buf,
@@ -73,313 +66,8 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
-					   itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-			AttrNumber	cmpcol = 1;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
-							&cmpcol) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
-
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
-					  NULL);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -423,6 +111,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	bool		inposting = false;
 	bool		prevalldead = true;
 	int			curposti = 0;
+	nbts_prep_ctx(rel);
 
 	/* Assume unique until we find a duplicate */
 	*is_unique = true;
@@ -774,253 +463,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				AttrNumber	cmpcol = 1;
-
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
-					break;
-
-				_bt_stepright(rel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			AttrNumber	cmpcol = 1;
-
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	{
-		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
-		Assert(P_RIGHTMOST(opaque) ||
-			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
-	}
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1501,6 +943,7 @@ _bt_split(Relation rel, BTScanInsert itup_key, Buffer buf, Buffer cbuf,
 	bool		newitemonleft,
 				isleaf,
 				isrightmost;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * origpage is the original page to be split.  leftpage is a temporary
@@ -2693,6 +2136,7 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 	BTScanInsert itup_key = insertstate->itup_key;
 	Page		page = BufferGetPage(buffer);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
+	nbts_prep_ctx(rel);
 
 	Assert(P_ISLEAF(opaque));
 	Assert(simpleonly || itup_key->heapkeyspace);
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
new file mode 100644
index 0000000000..d37afae5ae
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -0,0 +1,583 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtinsert_spec.c
+ *	  Index shape-specialized functions for nbtinsert.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtinsert_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_search_insert NBTS_FUNCTION(_bt_search_insert)
+#define _bt_findinsertloc NBTS_FUNCTION(_bt_findinsertloc)
+
+static BTStack _bt_search_insert(Relation rel, BTInsertState insertstate);
+static OffsetNumber _bt_findinsertloc(Relation rel,
+									  BTInsertState insertstate,
+									  bool checkingunique,
+									  bool indexUnchanged,
+									  BTStack stack,
+									  Relation heapRel);
+
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+_bt_doinsert(Relation rel, IndexTuple itup,
+			 IndexUniqueCheck checkUnique, bool indexUnchanged,
+			 Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = _bt_mkscankey(rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = _bt_search_insert(rel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
+									   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, itup_key, insertstate.buf, InvalidBuffer, stack,
+					   itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+_bt_search_insert(Relation rel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return _bt_search(rel, insertstate->itup_key, &insertstate->buf, BT_WRITE,
+					  NULL);
+}
+
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+_bt_findinsertloc(Relation rel,
+				  BTInsertState insertstate,
+				  bool checkingunique,
+				  bool indexUnchanged,
+				  BTStack stack,
+				  Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				AttrNumber	cmpcol = 1;
+
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
+					break;
+
+				_bt_stepright(rel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			AttrNumber	cmpcol = 1;
+
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
+
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 3feee28d19..7710226f41 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1819,6 +1819,7 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 	bool		rightsib_empty;
 	Page		page;
 	BTPageOpaque opaque;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Save original leafbuf block number from caller.  Only deleted blocks
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 1cc88da032..ceeafd637f 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,8 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -120,7 +122,7 @@ bthandler(PG_FUNCTION_ARGS)
 
 	amroutine->ambuild = btbuild;
 	amroutine->ambuildempty = btbuildempty;
-	amroutine->aminsert = btinsert;
+	amroutine->aminsert = btinsert_default;
 	amroutine->ambulkdelete = btbulkdelete;
 	amroutine->amvacuumcleanup = btvacuumcleanup;
 	amroutine->amcanreturn = btcanreturn;
@@ -152,6 +154,8 @@ btbuildempty(Relation index)
 {
 	Page		metapage;
 
+	nbt_opt_specialize(index);
+
 	/* Construct metapage. */
 	metapage = (Page) palloc(BLCKSZ);
 	_bt_initmetapage(metapage, P_NONE, 0, _bt_allequalimage(index, false));
@@ -177,33 +181,6 @@ btbuildempty(Relation index)
 	smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
@@ -345,6 +322,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -788,6 +767,8 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
 
+	nbt_opt_specialize(rel);
+
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
 		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
new file mode 100644
index 0000000000..6b766581ab
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -0,0 +1,69 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_spec.c
+ *	  Index shape-specialized functions for nbtree.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtree_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+_bt_specialize(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	NBTS_MAKE_CTX(rel);
+	/*
+	 * We can't directly address _bt_specialize here because it'd be macro-
+	 * expanded, nor can we utilize NBTS_SPECIALIZE_NAME here because it'd
+	 * try to call _bt_specialize, which would be an infinite recursive call.
+	 */
+	switch (__nbts_ctx) {
+		case NBTS_CTX_CACHED:
+			_bt_specialize_cached(rel);
+			break;
+		case NBTS_CTX_DEFAULT:
+			break;
+	}
+#else
+	rel->rd_indam->aminsert = btinsert;
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+btinsert(Relation rel, Datum *values, bool *isnull,
+		 ItemPointer ht_ctid, Relation heapRel,
+		 IndexUniqueCheck checkUnique,
+		 bool indexUnchanged,
+		 IndexInfo *indexInfo)
+{
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index e3b828137b..0089fe7eeb 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,12 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
-								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -47,6 +43,8 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -71,572 +69,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- */
-BTStack
-_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
-		   Snapshot snapshot)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-	char		tupdatabuf[BLCKSZ / 3];
-	AttrNumber	highkeycmpcol = 1;
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
-							  page_access, snapshot, &highkeycmpcol,
-							  (char *) tupdatabuf);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
-		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		highkeycmpcol = 1;
-
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split
- * is completed.  'stack' is only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  Snapshot snapshot,
-			  AttrNumber *comparecol,
-			  char *tupdatabuf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		AttrNumber	cmpcol = 1;
-
-		page = BufferGetPage(buf);
-		TestForOldSnapshot(snapshot, rel, page);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-		{
-			*comparecol = 1;
-			break;
-		}
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		/*
-		 * tupdatabuf is filled with the right seperator of the parent node.
-		 * This allows us to do a binary equality check between the parent
-		 * node's right seperator (which is < key) and this page's P_HIKEY.
-		 * If they equal, we can reuse the result of the parent node's
-		 * rightkey compare, which means we can potentially save a full key
-		 * compare (which includes indirect calls to attribute comparison
-		 * functions).
-		 * 
-		 * Without this, we'd on average use 3 full key compares per page before
-		 * we achieve full dynamic prefix bounds, but with this optimization
-		 * that is only 2.
-		 * 
-		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
-		 * we move right in the binary search on the page, this average equals
-		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
-		 */
-		if (!P_IGNORE(opaque) && *comparecol > 1)
-		{
-			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
-			IndexTuple buftuple = (IndexTuple) tupdatabuf;
-			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
-			{
-				char *dataptr = (char *) itup;
-
-				if (memcmp(dataptr + sizeof(IndexTupleData),
-						   tupdatabuf + sizeof(IndexTupleData),
-						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
-					break;
-			} else {
-				*comparecol = 1;
-			}
-		} else {
-			*comparecol = 1;
-		}
-
-		if (P_IGNORE(opaque) ||
-				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
-		{
-			*comparecol = 1;
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-		{
-			*comparecol = cmpcol;
-			break;
-		}
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf,
-			AttrNumber *highkeycmpcol)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-	AttrNumber	highcmpcol = *highkeycmpcol,
-				lowcmpcol = 1;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-		}
-	}
-	
-	*highkeycmpcol = highcmpcol;
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-				   AttrNumber highcmpcol)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-	AttrNumber	lowcmpcol = 1;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
-
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
  *
@@ -704,228 +136,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum,
-			AttrNumber *comparecol)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-
-	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-		{
-			*comparecol = i;
-			return result;
-		}
-
-		scankey++;
-	}
-
-	/*
-	 * All tuple attributes are equal to the scan key, only later attributes
-	 * could potentially not equal the scan key.
-	 */
-	*comparecol = ntupatts + 1;
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -967,6 +177,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(rel);
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1589,280 +800,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2071,12 +1008,11 @@ static bool
 _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 {
 	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Relation	rel;
+	Relation	rel = scan->indexRelation;
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
-
-	rel = scan->indexRelation;
+	nbts_prep_ctx(rel);
 
 	if (ScanDirectionIsForward(dir))
 	{
@@ -2488,6 +1424,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	BTPageOpaque opaque;
 	OffsetNumber start;
 	BTScanPosItem *currItem;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Scan down to the leftmost or rightmost leaf page.  This is a simplified
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
new file mode 100644
index 0000000000..37cc3647d3
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -0,0 +1,1087 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsearch_spec.c
+ *	  Index shape-specialized functions for nbtsearch.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsearch_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_binsrch		NBTS_FUNCTION(_bt_binsrch)
+#define _bt_readpage	NBTS_FUNCTION(_bt_readpage)
+
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
+static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
+						 OffsetNumber offnum);
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ */
+BTStack
+_bt_search(Relation rel, BTScanInsert key, Buffer *bufP, int access,
+		   Snapshot snapshot)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = _bt_moveright(rel, key, *bufP, (access == BT_WRITE), stack_in,
+							  page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		highkeycmpcol = 1;
+
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = _bt_moveright(rel, key, *bufP, true, stack_in, BT_WRITE,
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split
+ * is completed.  'stack' is only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ */
+Buffer
+_bt_moveright(Relation rel,
+			  BTScanInsert key,
+			  Buffer buf,
+			  bool forupdate,
+			  BTStack stack,
+			  int access,
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		AttrNumber	cmpcol = 1;
+
+		page = BufferGetPage(buf);
+		TestForOldSnapshot(snapshot, rel, page);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
+			break;
+		}
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+			_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
+		{
+			*comparecol = 1;
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+		{
+			*comparecol = cmpcol;
+			break;
+		}
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+_bt_binsrch(Relation rel,
+			BTScanInsert key,
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+		}
+	}
+
+	*highkeycmpcol = highcmpcol;
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+	AttrNumber	lowcmpcol = 1;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+_bt_compare(Relation rel,
+			BTScanInsert key,
+			Page page,
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+		{
+			*comparecol = i;
+			return result;
+		}
+
+		scankey++;
+	}
+
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 67b7b1710c..af408f704f 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,8 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -544,6 +544,7 @@ static void
 _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 {
 	BTWriteState wstate;
+	nbts_prep_ctx(btspool->index);
 
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
@@ -844,6 +845,7 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 	Size		pgspc;
 	Size		itupsz;
 	bool		isleaf;
+	nbts_prep_ctx(wstate->index);
 
 	/*
 	 * This is a handy place to check for cancel interrupts during the btree
@@ -1176,264 +1178,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			Assert(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
new file mode 100644
index 0000000000..368d6f244c
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -0,0 +1,280 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsort_spec.c
+ *	  Index shape-specialized functions for nbtsort.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsort_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_load NBTS_FUNCTION(_bt_load)
+
+static void _bt_load(BTWriteState *wstate,
+					 BTSpool *btspool, BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			Assert(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
+										 itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index ecb49bb471..991118fd50 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -639,6 +639,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	ItemId		itemid;
 	IndexTuple	tup;
 	int			keepnatts;
+	nbts_prep_ctx(state->rel);
 
 	Assert(state->is_leaf && !state->is_rightmost);
 
@@ -945,6 +946,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 			   *rightinterval;
 	int			perfectpenalty;
 	int			indnkeyatts = IndexRelationGetNumberOfKeyAttributes(state->rel);
+	nbts_prep_ctx(state->rel);
 
 	/* Assume that alternative strategy won't be used for now */
 	*strategy = SPLIT_DEFAULT;
@@ -1137,6 +1139,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 {
 	IndexTuple	lastleft;
 	IndexTuple	firstright;
+	nbts_prep_ctx(state->rel);
 
 	if (!state->is_leaf)
 	{
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 8003583c0a..85f92adda8 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,10 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.c"
+#include "access/nbtree_spec.h"
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1220,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1703,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
new file mode 100644
index 0000000000..0288da22d6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -0,0 +1,775 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtutils_spec.c
+ *	  Index shape-specialized functions for nbtutils.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtutils_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_check_rowcompare	NBTS_FUNCTION(_bt_check_rowcompare)
+#define _bt_keep_natts			NBTS_FUNCTION(_bt_keep_natts)
+
+static bool _bt_check_rowcompare(ScanKey skey,
+								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+								 ScanDirection dir, bool *continuescan);
+static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
+							 IndexTuple firstright, BTScanInsert itup_key);
+
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+_bt_mkscankey(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+			  ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
+									 continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
+					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			 BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			   BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index eb6cfcfd00..12f909e1cf 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -57,8 +57,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int tuplen);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static void writetup_index(Tuplesortstate *state, LogicalTape *tape,
@@ -130,6 +128,9 @@ typedef struct
 	int			datumTypeLen;
 } TuplesortDatumArg;
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesortvariants_spec.c"
+#include "access/nbtree_spec.h"
+
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
 					 int nkeys, AttrNumber *attNums,
@@ -217,6 +218,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 	MemoryContext oldcontext;
 	TuplesortClusterArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	Assert(indexRel->rd_rel->relam == BTREE_AM_OID);
 
@@ -328,6 +330,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	TuplesortIndexBTreeArg *arg;
 	MemoryContext oldcontext;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -461,6 +464,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 	MemoryContext oldcontext;
 	TuplesortIndexBTreeArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -1259,142 +1263,6 @@ removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
 	}
 }
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
-	SortSupport sortKey = base->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = base->nKeys;
-	tupDes = RelationGetDescr(arg->index.indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(arg->index.indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(arg->index.heapRel,
-									RelationGetRelationName(arg->index.indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
new file mode 100644
index 0000000000..0791f41136
--- /dev/null
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -0,0 +1,158 @@
+/*-------------------------------------------------------------------------
+ *
+ * tuplesortvariants_spec.c
+ *	  Index shape-specialized functions for tuplesortvariants.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/tuplesortvariants_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define comparetup_index_btree NBTS_FUNCTION(comparetup_index_btree)
+
+static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+								   Tuplesortstate *state);
+
+static int
+comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+					   Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
+	SortSupport sortKey = base->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	Datum		datum1,
+				datum2;
+	bool		isnull1,
+				isnull2;
+
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = base->nKeys;
+	tupDes = RelationGetDescr(arg->index.indexRel);
+
+	if (sortKey->abbrev_converter)
+	{
+		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
+
+		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
+												datum2, isnull2,
+												sortKey);
+		if (compare != 0)
+			return compare;
+	}
+
+	/* they are equal, so we only need to examine one null flag */
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	sortKey++;
+	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	{
+		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+
+		compare = ApplySortComparator(datum1, isnull1,
+									  datum2, isnull2,
+									  sortKey);
+		if (compare != 0)
+			return compare;		/* done when we find unequal attributes */
+
+		/* they are equal, so we only need to examine one null flag */
+		if (isnull1)
+			equal_hasnull = true;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(arg->index.indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(arg->index.heapRel,
+									   RelationGetRelationName(arg->index.indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 4cb24fa005..f3f0961052 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1122,15 +1122,27 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+typedef enum NBTS_CTX {
+	NBTS_CTX_CACHED, 
+	NBTS_CTX_DEFAULT, /* fallback */
+} NBTS_CTX;
+
+static inline NBTS_CTX _nbt_spec_context(Relation irel)
+{
+	if (!PointerIsValid(irel))
+		return NBTS_CTX_DEFAULT;
+
+	return NBTS_CTX_CACHED;
+}
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
+#include "nbtree_spec.h"
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1161,9 +1173,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
-						   IndexTuple newitem, Size newitemsz,
-						   bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1179,9 +1188,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Buffer lbuf, BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, BTStack stack, BlockNumber child);
 
@@ -1229,16 +1235,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
-						  int access, Snapshot snapshot);
-extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
-							bool forupdate, BTStack stack, int access,
-							Snapshot snapshot, AttrNumber *comparecol,
-							char *tupdatabuf);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-									   AttrNumber highcmpcol);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
-						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
@@ -1247,7 +1243,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1255,8 +1250,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1269,10 +1262,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
new file mode 100644
index 0000000000..fa38b09c6e
--- /dev/null
+++ b/src/include/access/nbtree_spec.h
@@ -0,0 +1,183 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ * - nbts_context(irel)
+ *   Constructs a context that is used to call specialized functions.
+ *   Note that this is unneeded in paths that are inaccessible to unspecialized
+ *   code paths (i.e. code included through nbtree_spec.h), because that
+ *   always calls the optimized functions directly.
+ */
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+#define NBTS_CTX_NAME __nbts_ctx
+
+/* contextual specializations */
+#define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
+#define NBTS_SPECIALIZE_NAME(name) ( \
+	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	) \
+)
+
+/* how do we make names? */
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define nbt_opt_specialize(rel) \
+do { \
+	Assert(PointerIsValid(rel)); \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
+	{ \
+		nbts_prep_ctx(rel); \
+		_bt_specialize(rel); \
+	} \
+} while (false)
+
+/*
+ * Protections against multiple inclusions - the definition of this macro is
+ * different for files included with the templating mechanism vs the users
+ * of this template, so redefine these macros at top and bottom.
+ */
+#ifdef NBTS_FUNCTION
+#undef NBTS_FUNCTION
+#endif
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+/* While specializing, the context is the local context */
+#ifdef nbts_prep_ctx
+#undef nbts_prep_ctx
+#endif
+#define nbts_prep_ctx(rel)
+
+/*
+ * Specialization 1: CACHED
+ *
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) do {} while (false)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_SPECIALIZING_CACHED
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * Specialization 2: DEFAULT
+ *
+ * "Default", externally accessible, not so optimized functions
+ */
+
+/* Only the default context may need to specialize in some cases, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * All next uses of nbts_prep_ctx are in non-templated code, so here we make
+ * sure we actually create the context.
+ */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+/*
+ * from here on all NBTS_FUNCTIONs are from specialized function names that
+ * are being called. Change the result of those macros from a direct call
+ * call to a conditional call to the right place, depending on the correct
+ * context.
+ */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) NBTS_SPECIALIZE_NAME(name)
+
+#undef NBT_SPECIALIZE_FILE
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
new file mode 100644
index 0000000000..ac60319eff
--- /dev/null
+++ b/src/include/access/nbtree_specfuncs.h
@@ -0,0 +1,66 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+#define _bt_specialize		NBTS_FUNCTION(_bt_specialize)
+#define btinsert			NBTS_FUNCTION(btinsert)
+#define _bt_dedup_pass		NBTS_FUNCTION(_bt_dedup_pass)
+#define _bt_doinsert		NBTS_FUNCTION(_bt_doinsert)
+#define _bt_search			NBTS_FUNCTION(_bt_search)
+#define _bt_moveright		NBTS_FUNCTION(_bt_moveright)
+#define _bt_binsrch_insert	NBTS_FUNCTION(_bt_binsrch_insert)
+#define _bt_compare			NBTS_FUNCTION(_bt_compare)
+#define _bt_mkscankey		NBTS_FUNCTION(_bt_mkscankey)
+#define _bt_checkkeys		NBTS_FUNCTION(_bt_checkkeys)
+#define _bt_truncate		NBTS_FUNCTION(_bt_truncate)
+#define _bt_keep_natts_fast	NBTS_FUNCTION(_bt_keep_natts_fast)
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void _bt_specialize(Relation rel);
+
+extern bool btinsert(Relation rel, Datum *values, bool *isnull,
+					 ItemPointer ht_ctid, Relation heapRel,
+					 IndexUniqueCheck checkUnique, bool indexUnchanged,
+					 struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void _bt_dedup_pass(Relation rel, Buffer buf, Relation heapRel,
+						   IndexTuple newitem, Size newitemsz,
+						   bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool _bt_doinsert(Relation rel, IndexTuple itup,
+						 IndexUniqueCheck checkUnique, bool indexUnchanged,
+						 Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack _bt_search(Relation rel, BTScanInsert key, Buffer *bufP,
+						  int access, Snapshot snapshot);
+extern Buffer _bt_moveright(Relation rel, BTScanInsert key, Buffer buf,
+							bool forupdate, BTStack stack, int access,
+							Snapshot snapshot, AttrNumber *comparecol,
+							char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
+extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+						  ScanDirection dir, bool *continuescan);
+extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright, BTScanInsert itup_key);
+extern int _bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright);
diff --git a/src/tools/pginclude/cpluspluscheck b/src/tools/pginclude/cpluspluscheck
index e52fe9f509..0b9997ef5d 100755
--- a/src/tools/pginclude/cpluspluscheck
+++ b/src/tools/pginclude/cpluspluscheck
@@ -116,6 +116,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
diff --git a/src/tools/pginclude/headerscheck b/src/tools/pginclude/headerscheck
index abbba7aa63..0350df58b8 100755
--- a/src/tools/pginclude/headerscheck
+++ b/src/tools/pginclude/headerscheck
@@ -111,6 +111,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
-- 
2.39.0

From 26f95a437cc6c6aa48e76bd4593306ae89823ea4 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 13 Jan 2023 15:42:41 +0100
Subject: [PATCH v10 6/6] btree specialization for variable-length
 multi-attribute keys

The default code path is relatively slow at O(n^2), so with multiple
attributes we accept the increased startup cost in favour of lower
costs for later attributes.

Note that this will only be used for indexes that use at least one
variable-length key attribute (except as last key attribute in specific
cases).
---
 src/backend/access/nbtree/README        |   6 +-
 src/backend/access/nbtree/nbtree_spec.c |   3 +
 src/include/access/itup_attiter.h       | 199 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  11 +-
 src/include/access/nbtree_spec.h        |  48 +++++-
 5 files changed, 258 insertions(+), 9 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 6864902637..1b9bfe6d89 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1105,14 +1105,12 @@ performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
  - indexes with only a single key attribute
+ - multi-column indexes that cannot pre-calculate the offsets of all key
+   attributes in the tuple data section
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
 
-Future work will optimize for multi-column indexes that don't benefit
-from the attcacheoff optimization by improving on the O(n^2) nature of
-index_getattr through storing attribute offsets.
-
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 21635397ed..699197dfa7 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_UNCACHED:
+			_bt_specialize_uncached(rel);
+			break;
 		case NBTS_CTX_SINGLE_KEYATT:
 			_bt_specialize_single_keyatt(rel);
 			break;
diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..c8fb6954bc
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,199 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup_attiter.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+#include "varatt.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 4628c41e9a..d5ed38bb71 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1124,18 +1125,26 @@ typedef struct BTOptions
 
 typedef enum NBTS_CTX {
 	NBTS_CTX_SINGLE_KEYATT, 
+	NBTS_CTX_UNCACHED,
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	AttrNumber	nKeyAtts;
+
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
-	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+	nKeyAtts = IndexRelationGetNumberOfKeyAttributes(irel);
+
+	if (nKeyAtts == 1)
 		return NBTS_CTX_SINGLE_KEYATT;
 
+	if (TupleDescAttr(irel->rd_att, nKeyAtts - 1)->attcacheoff < -1)
+		return NBTS_CTX_UNCACHED;
+
 	return NBTS_CTX_CACHED;
 }
 
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 8e476c300d..efed9824e7 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -45,6 +45,7 @@
  * Macros used in the nbtree specialization code.
  */
 #define NBTS_TYPE_SINGLE_KEYATT single_keyatt
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -53,8 +54,10 @@
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
 	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
-		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		(NBTS_CTX_NAME) == NBTS_CTX_UNCACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED)) : ( \
+			(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+				NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+			) \
 		) \
 	) \
 )
@@ -69,8 +72,11 @@ do { \
 	Assert(PointerIsValid(rel)); \
 	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
 	{ \
-		nbts_prep_ctx(rel); \
-		_bt_specialize(rel); \
+		PopulateTupleDescCacheOffsets((rel)->rd_att); \
+		{ \
+			nbts_prep_ctx(rel); \
+			_bt_specialize(rel); \
+		} \
 	} \
 } while (false)
 
@@ -216,6 +222,40 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All next uses of nbts_prep_ctx are in non-templated code, so here we make
  * sure we actually create the context.
-- 
2.39.0

From 8dfbc98b0ea4ff624fde3739156d8a4c3f12ca33 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 13 Jan 2023 15:42:41 +0100
Subject: [PATCH v11 6/6] btree specialization for variable-length
 multi-attribute keys

The default code path is relatively slow at O(n^2), so with multiple
attributes we accept the increased startup cost in favour of lower
costs for later attributes.

Note that this will only be used for indexes that use at least one
variable-length key attribute (except as last key attribute in specific
cases).
---
 src/backend/access/nbtree/README        |   6 +-
 src/backend/access/nbtree/nbtree_spec.c |   3 +
 src/include/access/itup_attiter.h       | 199 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  11 +-
 src/include/access/nbtree_spec.h        |  48 +++++-
 5 files changed, 258 insertions(+), 9 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index e90e24cb70..0c45288e61 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1105,14 +1105,12 @@ performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
  - indexes with only a single key attribute
+ - multi-column indexes that cannot pre-calculate the offsets of all key
+   attributes in the tuple data section
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
 
-Future work will optimize for multi-column indexes that don't benefit
-from the attcacheoff optimization by improving on the O(n^2) nature of
-index_getattr through storing attribute offsets.
-
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 21635397ed..699197dfa7 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_UNCACHED:
+			_bt_specialize_uncached(rel);
+			break;
 		case NBTS_CTX_SINGLE_KEYATT:
 			_bt_specialize_single_keyatt(rel);
 			break;
diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..c8fb6954bc
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,199 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup_attiter.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+#include "varatt.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 72fbf3a4c6..204e349872 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1123,18 +1124,26 @@ typedef struct BTOptions
 
 typedef enum NBTS_CTX {
 	NBTS_CTX_SINGLE_KEYATT, 
+	NBTS_CTX_UNCACHED,
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	AttrNumber	nKeyAtts;
+
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
-	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+	nKeyAtts = IndexRelationGetNumberOfKeyAttributes(irel);
+
+	if (nKeyAtts == 1)
 		return NBTS_CTX_SINGLE_KEYATT;
 
+	if (TupleDescAttr(irel->rd_att, nKeyAtts - 1)->attcacheoff < -1)
+		return NBTS_CTX_UNCACHED;
+
 	return NBTS_CTX_CACHED;
 }
 
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 8e476c300d..efed9824e7 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -45,6 +45,7 @@
  * Macros used in the nbtree specialization code.
  */
 #define NBTS_TYPE_SINGLE_KEYATT single_keyatt
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -53,8 +54,10 @@
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
 	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
-		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		(NBTS_CTX_NAME) == NBTS_CTX_UNCACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED)) : ( \
+			(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+				NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+			) \
 		) \
 	) \
 )
@@ -69,8 +72,11 @@ do { \
 	Assert(PointerIsValid(rel)); \
 	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
 	{ \
-		nbts_prep_ctx(rel); \
-		_bt_specialize(rel); \
+		PopulateTupleDescCacheOffsets((rel)->rd_att); \
+		{ \
+			nbts_prep_ctx(rel); \
+			_bt_specialize(rel); \
+		} \
 	} \
 } while (false)
 
@@ -216,6 +222,40 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All next uses of nbts_prep_ctx are in non-templated code, so here we make
  * sure we actually create the context.
-- 
2.39.0

From 7ee3514e21d0ec16be2e87c93847be661b913c32 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:57:21 +0100
Subject: [PATCH v11 3/6] Use specialized attribute iterators in the
 specialized source files

This is committed separately to make clear what substantial changes were
made to the pre-existing code.

Even though not all nbt*_spec functions have been updated; these functions
can now directly call (and inline, and optimize for) the specialized functions
they call, instead of having to determine the right specialization based on
the (potentially locally unavailable) index relation, making the specialization
of those functions still worth specializing/duplicating.
---
 src/backend/access/nbtree/nbtsearch_spec.c    | 18 +++---
 src/backend/access/nbtree/nbtsort_spec.c      | 24 +++----
 src/backend/access/nbtree/nbtutils_spec.c     | 62 ++++++++++++-------
 .../utils/sort/tuplesortvariants_spec.c       | 54 +++++++++-------
 4 files changed, 92 insertions(+), 66 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index 1e04caf090..f0bdcb9828 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -641,6 +641,7 @@ _bt_compare(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -673,23 +674,26 @@ _bt_compare(Relation rel,
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 
 	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
@@ -718,7 +722,7 @@ _bt_compare(Relation rel,
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
 		{
-			*comparecol = i;
+			*comparecol = nbts_attiter_attnum;
 			return result;
 		}
 
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index 368d6f244c..6f33cc4cc2 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -34,8 +34,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -57,7 +56,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -90,21 +89,24 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 			else if (itup != NULL)
 			{
 				int32		compare = 0;
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index 0288da22d6..07ca18f404 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -64,7 +64,7 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -95,7 +95,10 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -106,27 +109,30 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -675,6 +681,8 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -686,20 +694,22 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -707,6 +717,7 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -747,24 +758,27 @@ _bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 0791f41136..61c4826853 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -40,11 +40,8 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 	bool		equal_hasnull = false;
 	int			nkey;
 	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
 
 	/* Compare the leading sort key */
 	compare = ApplySortComparator(a->datum1, a->isnull1,
@@ -59,37 +56,46 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 	keysz = base->nKeys;
 	tupDes = RelationGetDescr(arg->index.indexRel);
 
-	if (sortKey->abbrev_converter)
+	if (!sortKey->abbrev_converter)
 	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
+		nkey = 2;
+		sortKey++;
+	}
+	else
+	{
+		nkey = 1;
 	}
 
 	/* they are equal, so we only need to examine one null flag */
 	if (a->isnull1)
 		equal_hasnull = true;
 
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
 	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+		Datum	datum1,
+				datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		else
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
 
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
 		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
+			return compare;
 
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
+		if (nbts_attiter_curattisnull(tuple1))
 			equal_hasnull = true;
+
+		sortKey++;
 	}
 
 	/*
-- 
2.39.0

From 3119760693d53acd871c8ead2ad6722b604ff388 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 20:04:56 +0100
Subject: [PATCH v11 4/6] Optimize nbts_attiter for nkeyatts==1 btrees

This removes the index_getattr_nocache call path, which has significant overhead, and uses constant 0 offset.
---
 src/backend/access/nbtree/README        |  1 +
 src/backend/access/nbtree/nbtree_spec.c |  3 ++
 src/include/access/nbtree.h             | 35 ++++++++++++++++
 src/include/access/nbtree_spec.h        | 56 ++++++++++++++++++++++++-
 4 files changed, 93 insertions(+), 2 deletions(-)

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index e9d0cf6ac1..e90e24cb70 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1104,6 +1104,7 @@ in the index AM to call the specialized functions, increasing the
 performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
+ - indexes with only a single key attribute
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 6b766581ab..21635397ed 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_SINGLE_KEYATT:
+			_bt_specialize_single_keyatt(rel);
+			break;
 		case NBTS_CTX_DEFAULT:
 			break;
 	}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index d1bbc4d2a8..72fbf3a4c6 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1122,6 +1122,7 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
 typedef enum NBTS_CTX {
+	NBTS_CTX_SINGLE_KEYATT, 
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
@@ -1131,9 +1132,43 @@ static inline NBTS_CTX _nbt_spec_context(Relation irel)
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
+	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+		return NBTS_CTX_SINGLE_KEYATT;
+
 	return NBTS_CTX_CACHED;
 }
 
+static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
+									bool *isNull)
+{
+	Datum	result;
+	if (IndexTupleHasNulls(tuple))
+	{
+		if (att_isnull(0, (bits8 *)(tuple) + sizeof(IndexTupleData)))
+		{
+			*isNull = true;
+			result = (Datum) 0;
+		}
+		else
+		{
+			*isNull = false;
+			result = fetchatt(TupleDescAttr(tupleDesc, 0),
+							  ((char *) tuple)
+							  + MAXALIGN(sizeof(IndexTupleData)
+							  + sizeof(IndexAttributeBitMapData)));
+		}
+	}
+	else
+	{
+		*isNull = false;
+		result = fetchatt(TupleDescAttr(tupleDesc, 0),
+						  ((char *) tuple)
+						  + MAXALIGN(sizeof(IndexTupleData)));
+	}
+
+	return result;
+}
+
 
 #define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
 #include "nbtree_spec.h"
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index fa38b09c6e..8e476c300d 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -44,6 +44,7 @@
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_KEYATT single_keyatt
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -51,8 +52,10 @@
 /* contextual specializations */
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
-	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
+		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		) \
 	) \
 )
 
@@ -164,6 +167,55 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 3: SINGLE_KEYATT
+ *
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path cannot be used for indexes with multiple key
++ *  columns, because it never considers the next column.
+ */
+
+/* the default context (and later contexts) do need to specialize, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel)
+
+#define NBTS_SPECIALIZING_SINGLE_KEYATT
+#define NBTS_TYPE NBTS_TYPE_SINGLE_KEYATT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	_bt_getfirstatt(itup, tupDesc, &NBTS_MAKE_NAME(itup, isNull)) \
+)
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_KEYATT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All next uses of nbts_prep_ctx are in non-templated code, so here we make
  * sure we actually create the context.
-- 
2.39.0

From b9891e737f142391e45e85f18993617eccae5a54 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 12 Jan 2023 21:34:36 +0100
Subject: [PATCH v11 5/6] Add an attcacheoff-populating function

It populates attcacheoff-capable attributes with the correct offset,
and fills attributes whose offset is uncacheable with an 'uncacheable'
indicator value; as opposed to -1 which signals "unknown".

This allows users of the API to remove redundant cycles that try to
cache the offset of attributes - instead of O(N-attrs) operations, this
one only requires a O(1) check.
---
 src/backend/access/common/tupdesc.c | 111 ++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |   2 +
 2 files changed, 113 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 7c5c390503..b3f543cd83 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -927,3 +927,114 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid offset value.
+ *
+ * Populates attcacheoff with a negative cache value when no offset
+ * can be calculated (due to e.g. variable length attributes).
+ * The negative value is a value relative to the last cacheable attribute
+ *   attcacheoff = -1 - (thisattno - cachedattno)
+ * so that the last attribute with cached offset can be found with
+ *   cachedattno = attcacheoff + 1 + thisattno
+ *   
+ * The value returned is the AttrNumber of the last (1-based) attribute that
+ * had its offset cached.
+ * 
+ * When the TupleDesc has 0 attributes, it returns 0.
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	currAttNo, lastCachedAttNo;
+
+	if (numberOfAttributes == 0)
+		return 0;
+
+	/* Non-negative value: this attribute is cached */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff >= 0)
+		return (AttrNumber) desc->natts;
+	/*
+	 * Attribute has been filled with relative offset to last cached value, but
+	 * it itself is unreachable.
+	 */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+		return (AttrNumber) (TupleDescAttr(desc, desc->natts - 1)->attcacheoff + 1 + desc->natts);
+
+	/* last attribute of the tupledesc may or may not support attcacheoff */
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	currAttNo = 1;
+	/*
+	 * Other code may have populated the value previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (currAttNo < numberOfAttributes &&
+		   TupleDescAttr(desc, currAttNo)->attcacheoff >= 0)
+		currAttNo++;
+
+	/*
+	 * Cache offset is undetermined. Start calculating offsets if possible.
+	 * 
+	 * When we exit this block, currAttNo will point at the first uncacheable
+	 * attribute, or past the end of the attribute array.
+	 */
+	if (currAttNo < numberOfAttributes &&
+		TupleDescAttr(desc, currAttNo)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, currAttNo - 1);
+		int32 off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (currAttNo < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, currAttNo);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+					{
+						att->attcacheoff = off;
+						currAttNo++;
+					}
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				currAttNo++;
+			}
+		}
+	}
+
+	Assert(currAttNo == numberOfAttributes || (
+		currAttNo < numberOfAttributes
+		&& TupleDescAttr(desc, (currAttNo - 1))->attcacheoff >= 0
+		&& TupleDescAttr(desc, currAttNo)->attcacheoff == -1
+	));
+	/*
+	 * No cacheable offsets left. Fill the rest with negative cache values,
+	 * but return the latest cached offset.
+	 */
+	lastCachedAttNo = currAttNo;
+
+	while (currAttNo < numberOfAttributes)
+	{
+		TupleDescAttr(desc, currAttNo)->attcacheoff = -1 - (currAttNo - lastCachedAttNo);
+		currAttNo++;
+	}
+
+	return lastCachedAttNo;
+}
\ No newline at end of file
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index b4286cf922..2673f2d0f3 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.39.0

From 6f6248dfb37b6bd6275d1b520e712d2bf83228d9 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Tue, 10 Jan 2023 21:45:44 +0100
Subject: [PATCH v11 1/6] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also have those prefixing attributes that equal the
scankey.

We cannot generally propagate this information to _binsrch on
lower pages, as this downstream page may have concurrently split
and/or have merged with its deleted left neighbour (see [0]),
which moves the keyspace of the linked page. We thus can only
trust the current state of this current page for this optimization,
which means we must validate this state each time we open the page.

Although this limits the overall applicability of the
performance improvement, it still allows for a nice performance
improvement in most cases where initial columns have many
duplicate values and a compare function that is not cheap.

As an exception to the above rule, most of the time a pages'
highkey is equal to the right seperator on the parent page due to
how btree splits are done. By storing this right seperator from
the parent page and then validating that the highkey of the child
page contains the exact same data, we can restore the right prefix
bound without having to call the relatively expensive _bt_compare.

In the worst-case scenario of a concurrent page split, we'd still
have to validate the full key, but that doesn't happen very often
when compared to the number of times we descend the btree.
---
 contrib/amcheck/verify_nbtree.c       |  17 ++--
 src/backend/access/nbtree/README      |  43 ++++++++++
 src/backend/access/nbtree/nbtinsert.c |  34 +++++---
 src/backend/access/nbtree/nbtsearch.c | 118 +++++++++++++++++++++++---
 src/include/access/nbtree.h           |   9 +-
 5 files changed, 187 insertions(+), 34 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 94a9759322..e57625b75c 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2701,6 +2701,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2710,13 +2711,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2778,6 +2779,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2788,7 +2790,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2840,10 +2842,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2863,10 +2866,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2901,13 +2905,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 52e646c7f7..0f10141a2f 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,49 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+saving the indirect function calls in the compare operation.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by a parent page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. [2,3) to [1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+There is positive news, though: A page split will put a binary copy of the
+page's highkey in the parent page. This means that we usually can reuse
+the compare result of the parent page's downlink's right sibling when we
+discover that their representation is binary equal. In general this will
+be the case, as only in concurrent page splits and deletes the downlink
+may not point to the page with the correct highkey bound (_bt_moveright
+only rarely actually moves right).
+
+To implement this, we copy the downlink's right differentiator key into a
+temporary buffer, which is then compared against the child pages' highkey.
+If they match, we reuse the compare result (plus prefix) we had for it from
+the parent page, if not, we need to do a full _bt_compare. Because memcpy +
+memcmp is cheap compared to _bt_compare, and because it's quite unlikely
+that we guess wrong this speeds up our _bt_moveright code (at cost of some
+stack memory in _bt_search and some overhead in case of a wrong prediction)
+
+Now that we have prefix bounds on the highest value of a page, the
+_bt_binsrch procedure will use this result as a rightmost prefix compare,
+and for each step in the binary search (that does not compare less than the
+insert key) improve the equal-prefix bounds.
+
+Using the above optimization, we now (on average) only need 2 full key
+compares per page (plus ceil(log2(ntupsperpage)) single-attribute compares),
+as opposed to the ceil(log2(ntupsperpage)) + 1 of a naive implementation;
+a significant improvement.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index d33f814a93..39e7e9b731 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -328,6 +328,7 @@ _bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -346,7 +347,8 @@ _bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -440,7 +442,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = _bt_binsrch_insert(rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -450,6 +452,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -485,7 +489,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(_bt_compare(rel, itup_key, page, offset, &cmpcol) < 0);
 				break;
 			}
 
@@ -510,7 +514,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (_bt_compare(rel, itup_key, page, offset, &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -720,11 +724,12 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -867,6 +872,8 @@ _bt_findinsertloc(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
+
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -884,7 +891,7 @@ _bt_findinsertloc(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, heapRel, insertstate, stack);
@@ -937,6 +944,8 @@ _bt_findinsertloc(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
+
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -967,7 +976,7 @@ _bt_findinsertloc(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -982,10 +991,13 @@ _bt_findinsertloc(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -1004,7 +1016,7 @@ _bt_findinsertloc(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index 7e05e58676..7423b76e1c 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,7 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
 static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
@@ -101,6 +102,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
 
 	/* heaprel must be set whenever _bt_allocbuf is reachable */
 	Assert(access == BT_READ || access == BT_WRITE);
@@ -137,7 +140,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * opportunity to finish splits of internal pages too.
 		 */
 		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access, snapshot);
+							  stack_in, page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -149,12 +153,15 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -188,6 +195,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		highkeycmpcol = 1;
+
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -198,7 +207,7 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
 	}
 
 	return stack_in;
@@ -247,13 +256,16 @@ _bt_moveright(Relation rel,
 			  bool forupdate,
 			  BTStack stack,
 			  int access,
-			  Snapshot snapshot)
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
 	Assert(!forupdate || heaprel != NULL);
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
 
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
@@ -276,12 +288,17 @@ _bt_moveright(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -307,14 +324,55 @@ _bt_moveright(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
 		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
+		{
+			*comparecol = 1;
 			/* step right one page */
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -347,7 +405,8 @@ _bt_moveright(Relation rel,
 static OffsetNumber
 _bt_binsrch(Relation rel,
 			BTScanInsert key,
-			Buffer buf)
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -355,6 +414,8 @@ _bt_binsrch(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -396,16 +457,25 @@ _bt_binsrch(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
+	
+	*highkeycmpcol = highcmpcol;
 
 	/*
 	 * At this point we have high == low, but be careful: they could point
@@ -449,7 +519,8 @@ _bt_binsrch(Relation rel,
  * list split).
  */
 OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -459,6 +530,7 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -509,16 +581,22 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
+
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -666,7 +744,8 @@ int32
 _bt_compare(Relation rel,
 			BTScanInsert key,
 			Page page,
-			OffsetNumber offnum)
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -706,8 +785,9 @@ _bt_compare(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
 	{
 		Datum		datum;
 		bool		isNull;
@@ -751,11 +831,20 @@ _bt_compare(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = i;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
@@ -886,6 +975,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	AttrNumber	cmpcol = 1;
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1402,7 +1492,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = _bt_binsrch(rel, &inskey, buf, &cmpcol);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 8891fa7973..11f4184107 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1234,9 +1234,12 @@ extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
 						  Buffer *bufP, int access, Snapshot snapshot);
 extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
 							Buffer buf, bool forupdate, BTStack stack,
-							int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
+							int access, Snapshot snapshot,
+							AttrNumber *comparecol, char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
-- 
2.39.0

From cce61ad3617f6966316cc743948ac0cb4ef8693a Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:13:04 +0100
Subject: [PATCH v11 2/6] Specialize nbtree functions on btree key shape.

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, and splits the code that can
benefit from attribute offset optimizations into separate files. This does
NOT yet update the code itself - it just makes the code compile cleanly.
The performance should be comparable if not the same.
---
 contrib/amcheck/verify_nbtree.c               |    6 +
 src/backend/access/nbtree/README              |   28 +
 src/backend/access/nbtree/nbtdedup.c          |  300 +----
 src/backend/access/nbtree/nbtdedup_spec.c     |  317 +++++
 src/backend/access/nbtree/nbtinsert.c         |  579 +--------
 src/backend/access/nbtree/nbtinsert_spec.c    |  584 +++++++++
 src/backend/access/nbtree/nbtpage.c           |    1 +
 src/backend/access/nbtree/nbtree.c            |   37 +-
 src/backend/access/nbtree/nbtree_spec.c       |   69 ++
 src/backend/access/nbtree/nbtsearch.c         | 1084 +---------------
 src/backend/access/nbtree/nbtsearch_spec.c    | 1096 +++++++++++++++++
 src/backend/access/nbtree/nbtsort.c           |  264 +---
 src/backend/access/nbtree/nbtsort_spec.c      |  280 +++++
 src/backend/access/nbtree/nbtsplitloc.c       |    3 +
 src/backend/access/nbtree/nbtutils.c          |  754 +-----------
 src/backend/access/nbtree/nbtutils_spec.c     |  775 ++++++++++++
 src/backend/utils/sort/tuplesortvariants.c    |  144 +--
 .../utils/sort/tuplesortvariants_spec.c       |  158 +++
 src/include/access/nbtree.h                   |   44 +-
 src/include/access/nbtree_spec.h              |  183 +++
 src/include/access/nbtree_specfuncs.h         |   65 +
 src/tools/pginclude/cpluspluscheck            |    2 +
 src/tools/pginclude/headerscheck              |    2 +
 23 files changed, 3625 insertions(+), 3150 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.c
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.c
 create mode 100644 src/backend/access/nbtree/nbtree_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.c
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.c
 create mode 100644 src/backend/utils/sort/tuplesortvariants_spec.c
 create mode 100644 src/include/access/nbtree_spec.h
 create mode 100644 src/include/access/nbtree_specfuncs.h

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index e57625b75c..10ed67bffe 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2680,6 +2680,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 	BTStack		stack;
 	Buffer		lbuf;
 	bool		exists;
+	nbts_prep_ctx(NULL);
 
 	key = _bt_mkscankey(state->rel, itup);
 	Assert(key->heapkeyspace && key->scantid != NULL);
@@ -2780,6 +2781,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2843,6 +2845,7 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2867,6 +2870,7 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2906,6 +2910,7 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -3141,6 +3146,7 @@ static inline BTScanInsert
 bt_mkscankey_pivotsearch(Relation rel, IndexTuple itup)
 {
 	BTScanInsert skey;
+	nbts_prep_ctx(NULL);
 
 	skey = _bt_mkscankey(rel, itup);
 	skey->pivotsearch = true;
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 0f10141a2f..e9d0cf6ac1 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1084,6 +1084,34 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+Notes about nbtree specialization
+---------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes
+with variable length attributes, due to our inability to cache the offset
+of each attribute into an on-disk tuple. To combat this, we'd have to either
+fully deserialize the tuple, or maintain our offset into the tuple as we
+iterate over the tuple's fields.
+
+Keeping track of this offset also has a non-negligible overhead too, so we'd
+prefer to not have to keep track of these offsets when we can use the cache.
+By specializing performance-sensitive search functions for these specific
+index tuple shapes and calling those selectively, we can keep the performance
+of cacheable attribute offsets where that is applicable, while improving
+performance where we currently would see O(n_atts^2) time iterating on
+variable-length attributes.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also the default path, and is comparatively slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index d4db0b28f2..4589ade267 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,260 +22,14 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
-			   bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple and add it to our temp page (newpage).
-			 * Else add pending interval's base tuple to the temp page as-is.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place, when this page's newly allocated right sibling page
-				 * gets its first deduplication pass).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -316,6 +70,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 	TM_IndexDeleteOp delstate;
 	bool		neverdedup;
 	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	nbts_prep_ctx(rel);
 
 	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
 	newitemsz += sizeof(ItemIdData);
@@ -752,55 +507,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
new file mode 100644
index 0000000000..4b280de980
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -0,0 +1,317 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtdedup_spec.c
+ *	  Index shape-specialized functions for nbtdedup.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtdedup_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_do_singleval NBTS_FUNCTION(_bt_do_singleval)
+
+static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
+							 OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
+			   bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				minoff,
+				maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+				 _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple and add it to our temp page (newpage).
+			 * Else add pending interval's base tuple to the temp page as-is.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place, when this page's newly allocated right sibling page
+				 * gets its first deduplication pass).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+_bt_do_singleval(Relation rel, Page page, BTDedupState state,
+				 OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 39e7e9b731..3607bd418e 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,28 +30,16 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, Relation heaprel,
-								 BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
 static void _bt_stepright(Relation rel, Relation heaprel,
 						  BTInsertState insertstate, BTStack stack);
-static void _bt_insertonpg(Relation rel, Relation heaprel, BTScanInsert itup_key,
-						   Buffer buf,
-						   Buffer cbuf,
-						   BTStack stack,
-						   IndexTuple itup,
-						   Size itemsz,
-						   OffsetNumber newitemoff,
-						   int postingoff,
+static void _bt_insertonpg(Relation rel, Relation heaprel,
+						   BTScanInsert itup_key, Buffer buf, Buffer cbuf,
+						   BTStack stack, IndexTuple itup, Size itemsz,
+						   OffsetNumber newitemoff, int postingoff,
 						   bool split_only_page);
 static Buffer _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key,
 						Buffer buf, Buffer cbuf, OffsetNumber newitemoff,
@@ -75,313 +63,8 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, heapRel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
-					   stack, itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-			AttrNumber	cmpcol = 1;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
-							&cmpcol) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
-
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
-					  BT_WRITE, NULL);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -425,6 +108,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	bool		inposting = false;
 	bool		prevalldead = true;
 	int			curposti = 0;
+	nbts_prep_ctx(rel);
 
 	/* Assume unique until we find a duplicate */
 	*is_unique = true;
@@ -776,253 +460,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				AttrNumber	cmpcol = 1;
-
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
-					break;
-
-				_bt_stepright(rel, heapRel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			AttrNumber	cmpcol = 1;
-
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, heapRel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	{
-		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
-		Assert(P_RIGHTMOST(opaque) ||
-			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
-	}
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1506,6 +943,7 @@ _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
 	bool		newitemonleft,
 				isleaf,
 				isrightmost;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * origpage is the original page to be split.  leftpage is a temporary
@@ -2706,6 +2144,7 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 	BTScanInsert itup_key = insertstate->itup_key;
 	Page		page = BufferGetPage(buffer);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
+	nbts_prep_ctx(rel);
 
 	Assert(P_ISLEAF(opaque));
 	Assert(simpleonly || itup_key->heapkeyspace);
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
new file mode 100644
index 0000000000..6915f22839
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -0,0 +1,584 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtinsert_spec.c
+ *	  Index shape-specialized functions for nbtinsert.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtinsert_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_search_insert NBTS_FUNCTION(_bt_search_insert)
+#define _bt_findinsertloc NBTS_FUNCTION(_bt_findinsertloc)
+
+static BTStack _bt_search_insert(Relation rel, Relation heaprel,
+								 BTInsertState insertstate);
+static OffsetNumber _bt_findinsertloc(Relation rel,
+									  BTInsertState insertstate,
+									  bool checkingunique,
+									  bool indexUnchanged,
+									  BTStack stack,
+									  Relation heapRel);
+
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+_bt_doinsert(Relation rel, IndexTuple itup,
+			 IndexUniqueCheck checkUnique, bool indexUnchanged,
+			 Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = _bt_mkscankey(rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = _bt_search_insert(rel, heapRel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
+									   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
+					   stack, itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
+					  BT_WRITE, NULL);
+}
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+_bt_findinsertloc(Relation rel,
+				  BTInsertState insertstate,
+				  bool checkingunique,
+				  bool indexUnchanged,
+				  BTStack stack,
+				  Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				AttrNumber	cmpcol = 1;
+
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
+					break;
+
+				_bt_stepright(rel, heapRel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			AttrNumber	cmpcol = 1;
+
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, heapRel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
+
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index c2050656e4..504fa37d99 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1810,6 +1810,7 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 	bool		rightsib_empty;
 	Page		page;
 	BTPageOpaque opaque;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Save original leafbuf block number from caller.  Only deleted blocks
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 4553aaee53..ff1611bfb8 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,8 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -121,7 +123,7 @@ bthandler(PG_FUNCTION_ARGS)
 
 	amroutine->ambuild = btbuild;
 	amroutine->ambuildempty = btbuildempty;
-	amroutine->aminsert = btinsert;
+	amroutine->aminsert = btinsert_default;
 	amroutine->ambulkdelete = btbulkdelete;
 	amroutine->amvacuumcleanup = btvacuumcleanup;
 	amroutine->amcanreturn = btcanreturn;
@@ -153,6 +155,8 @@ btbuildempty(Relation index)
 {
 	Page		metapage;
 
+	nbt_opt_specialize(index);
+
 	/* Construct metapage. */
 	metapage = (Page) palloc_aligned(BLCKSZ, PG_IO_ALIGN_SIZE, 0);
 	_bt_initmetapage(metapage, P_NONE, 0, _bt_allequalimage(index, false));
@@ -178,33 +182,6 @@ btbuildempty(Relation index)
 	smgrimmedsync(RelationGetSmgr(index), INIT_FORKNUM);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
@@ -346,6 +323,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -789,6 +768,8 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
 
+	nbt_opt_specialize(rel);
+
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
 		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
new file mode 100644
index 0000000000..6b766581ab
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -0,0 +1,69 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_spec.c
+ *	  Index shape-specialized functions for nbtree.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtree_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+_bt_specialize(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	NBTS_MAKE_CTX(rel);
+	/*
+	 * We can't directly address _bt_specialize here because it'd be macro-
+	 * expanded, nor can we utilize NBTS_SPECIALIZE_NAME here because it'd
+	 * try to call _bt_specialize, which would be an infinite recursive call.
+	 */
+	switch (__nbts_ctx) {
+		case NBTS_CTX_CACHED:
+			_bt_specialize_cached(rel);
+			break;
+		case NBTS_CTX_DEFAULT:
+			break;
+	}
+#else
+	rel->rd_indam->aminsert = btinsert;
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+btinsert(Relation rel, Datum *values, bool *isnull,
+		 ItemPointer ht_ctid, Relation heapRel,
+		 IndexUniqueCheck checkUnique,
+		 bool indexUnchanged,
+		 IndexInfo *indexInfo)
+{
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index 7423b76e1c..4c853f1e4b 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -25,12 +25,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
-								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -47,6 +43,8 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -71,581 +69,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- *
- * heaprel must be provided by callers that pass access = BT_WRITE, since we
- * might need to allocate a new root page for caller -- see _bt_allocbuf.
- */
-BTStack
-_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
-		   int access, Snapshot snapshot)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-	char		tupdatabuf[BLCKSZ / 3];
-	AttrNumber	highkeycmpcol = 1;
-
-	/* heaprel must be set whenever _bt_allocbuf is reachable */
-	Assert(access == BT_READ || access == BT_WRITE);
-	Assert(access == BT_READ || heaprel != NULL);
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, heaprel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access, snapshot, &highkeycmpcol,
-							  (char *) tupdatabuf);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
-		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		highkeycmpcol = 1;
-
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split is
- * completed.  'heaprel' and 'stack' are only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  Relation heaprel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  Snapshot snapshot,
-			  AttrNumber *comparecol,
-			  char *tupdatabuf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	Assert(!forupdate || heaprel != NULL);
-	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		AttrNumber	cmpcol = 1;
-
-		page = BufferGetPage(buf);
-		TestForOldSnapshot(snapshot, rel, page);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-		{
-			*comparecol = 1;
-			break;
-		}
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, heaprel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		/*
-		 * tupdatabuf is filled with the right seperator of the parent node.
-		 * This allows us to do a binary equality check between the parent
-		 * node's right seperator (which is < key) and this page's P_HIKEY.
-		 * If they equal, we can reuse the result of the parent node's
-		 * rightkey compare, which means we can potentially save a full key
-		 * compare (which includes indirect calls to attribute comparison
-		 * functions).
-		 * 
-		 * Without this, we'd on average use 3 full key compares per page before
-		 * we achieve full dynamic prefix bounds, but with this optimization
-		 * that is only 2.
-		 * 
-		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
-		 * we move right in the binary search on the page, this average equals
-		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
-		 */
-		if (!P_IGNORE(opaque) && *comparecol > 1)
-		{
-			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
-			IndexTuple buftuple = (IndexTuple) tupdatabuf;
-			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
-			{
-				char *dataptr = (char *) itup;
-
-				if (memcmp(dataptr + sizeof(IndexTupleData),
-						   tupdatabuf + sizeof(IndexTupleData),
-						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
-					break;
-			} else {
-				*comparecol = 1;
-			}
-		} else {
-			*comparecol = 1;
-		}
-
-		if (P_IGNORE(opaque) ||
-				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
-		{
-			*comparecol = 1;
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-		{
-			*comparecol = cmpcol;
-			break;
-		}
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf,
-			AttrNumber *highkeycmpcol)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-	AttrNumber	highcmpcol = *highkeycmpcol,
-				lowcmpcol = 1;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-		}
-	}
-	
-	*highkeycmpcol = highcmpcol;
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-				   AttrNumber highcmpcol)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-	AttrNumber	lowcmpcol = 1;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
-
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
  *
@@ -713,228 +136,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum,
-			AttrNumber *comparecol)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-
-	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-		{
-			*comparecol = i;
-			return result;
-		}
-
-		scankey++;
-	}
-
-	/*
-	 * All tuple attributes are equal to the scan key, only later attributes
-	 * could potentially not equal the scan key.
-	 */
-	*comparecol = ntupatts + 1;
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -976,6 +177,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(rel);
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1598,280 +800,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2080,12 +1008,11 @@ static bool
 _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 {
 	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Relation	rel;
+	Relation	rel = scan->indexRelation;
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
-
-	rel = scan->indexRelation;
+	nbts_prep_ctx(rel);
 
 	if (ScanDirectionIsForward(dir))
 	{
@@ -2497,6 +1424,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	BTPageOpaque opaque;
 	OffsetNumber start;
 	BTScanPosItem *currItem;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Scan down to the leftmost or rightmost leaf page.  This is a simplified
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
new file mode 100644
index 0000000000..1e04caf090
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -0,0 +1,1096 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsearch_spec.c
+ *	  Index shape-specialized functions for nbtsearch.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsearch_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_binsrch		NBTS_FUNCTION(_bt_binsrch)
+#define _bt_readpage	NBTS_FUNCTION(_bt_readpage)
+
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
+static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
+						 OffsetNumber offnum);
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ *
+ * heaprel must be provided by callers that pass access = BT_WRITE, since we
+ * might need to allocate a new root page for caller -- see _bt_allocbuf.
+ */
+BTStack
+_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
+		   int access, Snapshot snapshot)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
+
+	/* heaprel must be set whenever _bt_allocbuf is reachable */
+	Assert(access == BT_READ || access == BT_WRITE);
+	Assert(access == BT_READ || heaprel != NULL);
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, heaprel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
+							  stack_in, page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		highkeycmpcol = 1;
+
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split is
+ * completed.  'heaprel' and 'stack' are only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ */
+Buffer
+_bt_moveright(Relation rel,
+			  Relation heaprel,
+			  BTScanInsert key,
+			  Buffer buf,
+			  bool forupdate,
+			  BTStack stack,
+			  int access,
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	Assert(!forupdate || heaprel != NULL);
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		AttrNumber	cmpcol = 1;
+
+		page = BufferGetPage(buf);
+		TestForOldSnapshot(snapshot, rel, page);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
+			break;
+		}
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, heaprel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+			_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
+		{
+			*comparecol = 1;
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+		{
+			*comparecol = cmpcol;
+			break;
+		}
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+_bt_binsrch(Relation rel,
+			BTScanInsert key,
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+		}
+	}
+
+	*highkeycmpcol = highcmpcol;
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+	AttrNumber	lowcmpcol = 1;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+_bt_compare(Relation rel,
+			BTScanInsert key,
+			Page page,
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+		{
+			*comparecol = i;
+			return result;
+		}
+
+		scankey++;
+	}
+
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index c2665fce41..8742716383 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,8 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -544,6 +544,7 @@ static void
 _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 {
 	BTWriteState wstate;
+	nbts_prep_ctx(btspool->index);
 
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
@@ -846,6 +847,7 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 	Size		pgspc;
 	Size		itupsz;
 	bool		isleaf;
+	nbts_prep_ctx(wstate->index);
 
 	/*
 	 * This is a handy place to check for cancel interrupts during the btree
@@ -1178,264 +1180,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			Assert(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
new file mode 100644
index 0000000000..368d6f244c
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -0,0 +1,280 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsort_spec.c
+ *	  Index shape-specialized functions for nbtsort.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsort_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_load NBTS_FUNCTION(_bt_load)
+
+static void _bt_load(BTWriteState *wstate,
+					 BTSpool *btspool, BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			Assert(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
+										 itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index 43b67893d9..db2da1e303 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -639,6 +639,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	ItemId		itemid;
 	IndexTuple	tup;
 	int			keepnatts;
+	nbts_prep_ctx(state->rel);
 
 	Assert(state->is_leaf && !state->is_rightmost);
 
@@ -945,6 +946,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 			   *rightinterval;
 	int			perfectpenalty;
 	int			indnkeyatts = IndexRelationGetNumberOfKeyAttributes(state->rel);
+	nbts_prep_ctx(state->rel);
 
 	/* Assume that alternative strategy won't be used for now */
 	*strategy = SPLIT_DEFAULT;
@@ -1137,6 +1139,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 {
 	IndexTuple	lastleft;
 	IndexTuple	firstright;
+	nbts_prep_ctx(state->rel);
 
 	if (!state->is_leaf)
 	{
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 7da499c4dd..37d644e9f3 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,10 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.c"
+#include "access/nbtree_spec.h"
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1220,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1703,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
new file mode 100644
index 0000000000..0288da22d6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -0,0 +1,775 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtutils_spec.c
+ *	  Index shape-specialized functions for nbtutils.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtutils_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_check_rowcompare	NBTS_FUNCTION(_bt_check_rowcompare)
+#define _bt_keep_natts			NBTS_FUNCTION(_bt_keep_natts)
+
+static bool _bt_check_rowcompare(ScanKey skey,
+								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+								 ScanDirection dir, bool *continuescan);
+static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
+							 IndexTuple firstright, BTScanInsert itup_key);
+
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+_bt_mkscankey(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+			  ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
+									 continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
+					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			 BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			   BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index eb6cfcfd00..12f909e1cf 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -57,8 +57,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int tuplen);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static void writetup_index(Tuplesortstate *state, LogicalTape *tape,
@@ -130,6 +128,9 @@ typedef struct
 	int			datumTypeLen;
 } TuplesortDatumArg;
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesortvariants_spec.c"
+#include "access/nbtree_spec.h"
+
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
 					 int nkeys, AttrNumber *attNums,
@@ -217,6 +218,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 	MemoryContext oldcontext;
 	TuplesortClusterArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	Assert(indexRel->rd_rel->relam == BTREE_AM_OID);
 
@@ -328,6 +330,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	TuplesortIndexBTreeArg *arg;
 	MemoryContext oldcontext;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -461,6 +464,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 	MemoryContext oldcontext;
 	TuplesortIndexBTreeArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -1259,142 +1263,6 @@ removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
 	}
 }
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
-	SortSupport sortKey = base->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = base->nKeys;
-	tupDes = RelationGetDescr(arg->index.indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(arg->index.indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(arg->index.heapRel,
-									RelationGetRelationName(arg->index.indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
new file mode 100644
index 0000000000..0791f41136
--- /dev/null
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -0,0 +1,158 @@
+/*-------------------------------------------------------------------------
+ *
+ * tuplesortvariants_spec.c
+ *	  Index shape-specialized functions for tuplesortvariants.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/tuplesortvariants_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define comparetup_index_btree NBTS_FUNCTION(comparetup_index_btree)
+
+static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+								   Tuplesortstate *state);
+
+static int
+comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+					   Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
+	SortSupport sortKey = base->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	Datum		datum1,
+				datum2;
+	bool		isnull1,
+				isnull2;
+
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = base->nKeys;
+	tupDes = RelationGetDescr(arg->index.indexRel);
+
+	if (sortKey->abbrev_converter)
+	{
+		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
+
+		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
+												datum2, isnull2,
+												sortKey);
+		if (compare != 0)
+			return compare;
+	}
+
+	/* they are equal, so we only need to examine one null flag */
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	sortKey++;
+	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	{
+		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+
+		compare = ApplySortComparator(datum1, isnull1,
+									  datum2, isnull2,
+									  sortKey);
+		if (compare != 0)
+			return compare;		/* done when we find unequal attributes */
+
+		/* they are equal, so we only need to examine one null flag */
+		if (isnull1)
+			equal_hasnull = true;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(arg->index.indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(arg->index.heapRel,
+									   RelationGetRelationName(arg->index.indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 11f4184107..d1bbc4d2a8 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1121,15 +1121,27 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+typedef enum NBTS_CTX {
+	NBTS_CTX_CACHED, 
+	NBTS_CTX_DEFAULT, /* fallback */
+} NBTS_CTX;
+
+static inline NBTS_CTX _nbt_spec_context(Relation irel)
+{
+	if (!PointerIsValid(irel))
+		return NBTS_CTX_DEFAULT;
+
+	return NBTS_CTX_CACHED;
+}
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
+#include "nbtree_spec.h"
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1160,8 +1172,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
-						   Size newitemsz, bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1177,9 +1187,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Relation heaprel, Buffer lbuf,
 							 BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, Relation heaprel, BTStack stack,
@@ -1230,16 +1237,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
-						  Buffer *bufP, int access, Snapshot snapshot);
-extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
-							Buffer buf, bool forupdate, BTStack stack,
-							int access, Snapshot snapshot,
-							AttrNumber *comparecol, char *tupdatabuf);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-									   AttrNumber highcmpcol);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
-						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
@@ -1248,7 +1245,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1256,8 +1252,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1270,10 +1264,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
new file mode 100644
index 0000000000..fa38b09c6e
--- /dev/null
+++ b/src/include/access/nbtree_spec.h
@@ -0,0 +1,183 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ * - nbts_context(irel)
+ *   Constructs a context that is used to call specialized functions.
+ *   Note that this is unneeded in paths that are inaccessible to unspecialized
+ *   code paths (i.e. code included through nbtree_spec.h), because that
+ *   always calls the optimized functions directly.
+ */
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+#define NBTS_CTX_NAME __nbts_ctx
+
+/* contextual specializations */
+#define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
+#define NBTS_SPECIALIZE_NAME(name) ( \
+	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	) \
+)
+
+/* how do we make names? */
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define nbt_opt_specialize(rel) \
+do { \
+	Assert(PointerIsValid(rel)); \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
+	{ \
+		nbts_prep_ctx(rel); \
+		_bt_specialize(rel); \
+	} \
+} while (false)
+
+/*
+ * Protections against multiple inclusions - the definition of this macro is
+ * different for files included with the templating mechanism vs the users
+ * of this template, so redefine these macros at top and bottom.
+ */
+#ifdef NBTS_FUNCTION
+#undef NBTS_FUNCTION
+#endif
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+/* While specializing, the context is the local context */
+#ifdef nbts_prep_ctx
+#undef nbts_prep_ctx
+#endif
+#define nbts_prep_ctx(rel)
+
+/*
+ * Specialization 1: CACHED
+ *
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) do {} while (false)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_SPECIALIZING_CACHED
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * Specialization 2: DEFAULT
+ *
+ * "Default", externally accessible, not so optimized functions
+ */
+
+/* Only the default context may need to specialize in some cases, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * All next uses of nbts_prep_ctx are in non-templated code, so here we make
+ * sure we actually create the context.
+ */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+/*
+ * from here on all NBTS_FUNCTIONs are from specialized function names that
+ * are being called. Change the result of those macros from a direct call
+ * call to a conditional call to the right place, depending on the correct
+ * context.
+ */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) NBTS_SPECIALIZE_NAME(name)
+
+#undef NBT_SPECIALIZE_FILE
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
new file mode 100644
index 0000000000..b87f5bf802
--- /dev/null
+++ b/src/include/access/nbtree_specfuncs.h
@@ -0,0 +1,65 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+#define _bt_specialize		NBTS_FUNCTION(_bt_specialize)
+#define btinsert			NBTS_FUNCTION(btinsert)
+#define _bt_dedup_pass		NBTS_FUNCTION(_bt_dedup_pass)
+#define _bt_doinsert		NBTS_FUNCTION(_bt_doinsert)
+#define _bt_search			NBTS_FUNCTION(_bt_search)
+#define _bt_moveright		NBTS_FUNCTION(_bt_moveright)
+#define _bt_binsrch_insert	NBTS_FUNCTION(_bt_binsrch_insert)
+#define _bt_compare			NBTS_FUNCTION(_bt_compare)
+#define _bt_mkscankey		NBTS_FUNCTION(_bt_mkscankey)
+#define _bt_checkkeys		NBTS_FUNCTION(_bt_checkkeys)
+#define _bt_truncate		NBTS_FUNCTION(_bt_truncate)
+#define _bt_keep_natts_fast	NBTS_FUNCTION(_bt_keep_natts_fast)
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void _bt_specialize(Relation rel);
+
+extern bool btinsert(Relation rel, Datum *values, bool *isnull,
+					 ItemPointer ht_ctid, Relation heapRel,
+					 IndexUniqueCheck checkUnique, bool indexUnchanged,
+					 struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
+						   Size newitemsz, bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool _bt_doinsert(Relation rel, IndexTuple itup,
+						 IndexUniqueCheck checkUnique, bool indexUnchanged,
+						 Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
+						  Buffer *bufP, int access, Snapshot snapshot);
+extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
+							Buffer buf, bool forupdate, BTStack stack,
+							int access, Snapshot snapshot,
+							AttrNumber *comparecol, char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
+extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+						  ScanDirection dir, bool *continuescan);
+extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright, BTScanInsert itup_key);
+extern int _bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright);
diff --git a/src/tools/pginclude/cpluspluscheck b/src/tools/pginclude/cpluspluscheck
index 4e09c4686b..e504a2f114 100755
--- a/src/tools/pginclude/cpluspluscheck
+++ b/src/tools/pginclude/cpluspluscheck
@@ -116,6 +116,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
diff --git a/src/tools/pginclude/headerscheck b/src/tools/pginclude/headerscheck
index 8dee1b5670..101888c806 100755
--- a/src/tools/pginclude/headerscheck
+++ b/src/tools/pginclude/headerscheck
@@ -111,6 +111,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
-- 
2.39.0

From 73a38766c8bc32fc49d3acea32b66b47ff9ab030 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:57:21 +0100
Subject: [PATCH v12 3/6] Use specialized attribute iterators in the
 specialized source files

This is committed separately to make clear what substantial changes were
made to the pre-existing code.

Even though not all nbt*_spec functions have been updated; these functions
can now directly call (and inline, and optimize for) the specialized functions
they call, instead of having to determine the right specialization based on
the (potentially locally unavailable) index relation, making the specialization
of those functions still worth specializing/duplicating.
---
 src/backend/access/nbtree/nbtsearch_spec.c    | 18 +++---
 src/backend/access/nbtree/nbtsort_spec.c      | 24 +++----
 src/backend/access/nbtree/nbtutils_spec.c     | 62 ++++++++++++-------
 .../utils/sort/tuplesortvariants_spec.c       | 53 +++++++++-------
 4 files changed, 92 insertions(+), 65 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index 5f1ead2400..c03aed3fd7 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -668,6 +668,7 @@ _bt_compare(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -700,23 +701,26 @@ _bt_compare(Relation rel,
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 
 	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
@@ -745,7 +749,7 @@ _bt_compare(Relation rel,
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
 		{
-			*comparecol = i;
+			*comparecol = nbts_attiter_attnum;
 			return result;
 		}
 
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index 368d6f244c..6f33cc4cc2 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -34,8 +34,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -57,7 +56,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -90,21 +89,24 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 			else if (itup != NULL)
 			{
 				int32		compare = 0;
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index 0288da22d6..07ca18f404 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -64,7 +64,7 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -95,7 +95,10 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -106,27 +109,30 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -675,6 +681,8 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -686,20 +694,22 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -707,6 +717,7 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -747,24 +758,27 @@ _bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 705da09329..cf262eee2d 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -66,47 +66,54 @@ comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
 	bool		equal_hasnull = false;
 	int			nkey;
 	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
 
 	tuple1 = (IndexTuple) a->tuple;
 	tuple2 = (IndexTuple) b->tuple;
 	keysz = base->nKeys;
 	tupDes = RelationGetDescr(arg->index.indexRel);
 
-	if (sortKey->abbrev_converter)
+	if (!sortKey->abbrev_converter)
 	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
+		nkey = 2;
+		sortKey++;
+	}
+	else
+	{
+		nkey = 1;
 	}
 
 	/* they are equal, so we only need to examine one null flag */
 	if (a->isnull1)
 		equal_hasnull = true;
 
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
 	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+		Datum	datum1,
+				datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		else
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
 
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
 		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
+			return compare;
 
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
+		if (nbts_attiter_curattisnull(tuple1))
 			equal_hasnull = true;
+
+		sortKey++;
 	}
 
 	/*
-- 
2.40.1

From aff7566e784ca0f810b65effcd7a121781b11e37 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 12 Jan 2023 21:34:36 +0100
Subject: [PATCH v12 5/6] Add an attcacheoff-populating function

It populates attcacheoff-capable attributes with the correct offset,
and fills attributes whose offset is uncacheable with an 'uncacheable'
indicator value; as opposed to -1 which signals "unknown".

This allows users of the API to remove redundant cycles that try to
cache the offset of attributes - instead of O(N-attrs) operations, this
one only requires a O(1) check.
---
 src/backend/access/common/tupdesc.c | 111 ++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |   2 +
 2 files changed, 113 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 7c5c390503..b3f543cd83 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -927,3 +927,114 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid offset value.
+ *
+ * Populates attcacheoff with a negative cache value when no offset
+ * can be calculated (due to e.g. variable length attributes).
+ * The negative value is a value relative to the last cacheable attribute
+ *   attcacheoff = -1 - (thisattno - cachedattno)
+ * so that the last attribute with cached offset can be found with
+ *   cachedattno = attcacheoff + 1 + thisattno
+ *   
+ * The value returned is the AttrNumber of the last (1-based) attribute that
+ * had its offset cached.
+ * 
+ * When the TupleDesc has 0 attributes, it returns 0.
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	currAttNo, lastCachedAttNo;
+
+	if (numberOfAttributes == 0)
+		return 0;
+
+	/* Non-negative value: this attribute is cached */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff >= 0)
+		return (AttrNumber) desc->natts;
+	/*
+	 * Attribute has been filled with relative offset to last cached value, but
+	 * it itself is unreachable.
+	 */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+		return (AttrNumber) (TupleDescAttr(desc, desc->natts - 1)->attcacheoff + 1 + desc->natts);
+
+	/* last attribute of the tupledesc may or may not support attcacheoff */
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	currAttNo = 1;
+	/*
+	 * Other code may have populated the value previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (currAttNo < numberOfAttributes &&
+		   TupleDescAttr(desc, currAttNo)->attcacheoff >= 0)
+		currAttNo++;
+
+	/*
+	 * Cache offset is undetermined. Start calculating offsets if possible.
+	 * 
+	 * When we exit this block, currAttNo will point at the first uncacheable
+	 * attribute, or past the end of the attribute array.
+	 */
+	if (currAttNo < numberOfAttributes &&
+		TupleDescAttr(desc, currAttNo)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, currAttNo - 1);
+		int32 off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (currAttNo < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, currAttNo);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+					{
+						att->attcacheoff = off;
+						currAttNo++;
+					}
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				currAttNo++;
+			}
+		}
+	}
+
+	Assert(currAttNo == numberOfAttributes || (
+		currAttNo < numberOfAttributes
+		&& TupleDescAttr(desc, (currAttNo - 1))->attcacheoff >= 0
+		&& TupleDescAttr(desc, currAttNo)->attcacheoff == -1
+	));
+	/*
+	 * No cacheable offsets left. Fill the rest with negative cache values,
+	 * but return the latest cached offset.
+	 */
+	lastCachedAttNo = currAttNo;
+
+	while (currAttNo < numberOfAttributes)
+	{
+		TupleDescAttr(desc, currAttNo)->attcacheoff = -1 - (currAttNo - lastCachedAttNo);
+		currAttNo++;
+	}
+
+	return lastCachedAttNo;
+}
\ No newline at end of file
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index b4286cf922..2673f2d0f3 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.40.1

From f483508da0eac4edcf63ff56f05de4f954e104bf Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 20:04:56 +0100
Subject: [PATCH v12 4/6] Optimize nbts_attiter for nkeyatts==1 btrees

This removes the index_getattr_nocache call path, which has significant overhead, and uses constant 0 offset.
---
 src/backend/access/nbtree/README        |  1 +
 src/backend/access/nbtree/nbtree_spec.c |  3 ++
 src/include/access/nbtree.h             | 35 ++++++++++++++++
 src/include/access/nbtree_spec.h        | 56 ++++++++++++++++++++++++-
 4 files changed, 93 insertions(+), 2 deletions(-)

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index e9d0cf6ac1..e90e24cb70 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1104,6 +1104,7 @@ in the index AM to call the specialized functions, increasing the
 performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
+ - indexes with only a single key attribute
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 6b766581ab..21635397ed 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_SINGLE_KEYATT:
+			_bt_specialize_single_keyatt(rel);
+			break;
 		case NBTS_CTX_DEFAULT:
 			break;
 	}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index d1bbc4d2a8..72fbf3a4c6 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1122,6 +1122,7 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
 typedef enum NBTS_CTX {
+	NBTS_CTX_SINGLE_KEYATT, 
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
@@ -1131,9 +1132,43 @@ static inline NBTS_CTX _nbt_spec_context(Relation irel)
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
+	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+		return NBTS_CTX_SINGLE_KEYATT;
+
 	return NBTS_CTX_CACHED;
 }
 
+static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
+									bool *isNull)
+{
+	Datum	result;
+	if (IndexTupleHasNulls(tuple))
+	{
+		if (att_isnull(0, (bits8 *)(tuple) + sizeof(IndexTupleData)))
+		{
+			*isNull = true;
+			result = (Datum) 0;
+		}
+		else
+		{
+			*isNull = false;
+			result = fetchatt(TupleDescAttr(tupleDesc, 0),
+							  ((char *) tuple)
+							  + MAXALIGN(sizeof(IndexTupleData)
+							  + sizeof(IndexAttributeBitMapData)));
+		}
+	}
+	else
+	{
+		*isNull = false;
+		result = fetchatt(TupleDescAttr(tupleDesc, 0),
+						  ((char *) tuple)
+						  + MAXALIGN(sizeof(IndexTupleData)));
+	}
+
+	return result;
+}
+
 
 #define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
 #include "nbtree_spec.h"
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index fa38b09c6e..8e476c300d 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -44,6 +44,7 @@
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_KEYATT single_keyatt
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -51,8 +52,10 @@
 /* contextual specializations */
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
-	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
+		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		) \
 	) \
 )
 
@@ -164,6 +167,55 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 3: SINGLE_KEYATT
+ *
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path cannot be used for indexes with multiple key
++ *  columns, because it never considers the next column.
+ */
+
+/* the default context (and later contexts) do need to specialize, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel)
+
+#define NBTS_SPECIALIZING_SINGLE_KEYATT
+#define NBTS_TYPE NBTS_TYPE_SINGLE_KEYATT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	_bt_getfirstatt(itup, tupDesc, &NBTS_MAKE_NAME(itup, isNull)) \
+)
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_KEYATT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All next uses of nbts_prep_ctx are in non-templated code, so here we make
  * sure we actually create the context.
-- 
2.40.1

From bbc222f8ce4d06f16606ab5ea52f5dc420ba3cb1 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:13:04 +0100
Subject: [PATCH v12 2/6] Specialize nbtree functions on btree key shape.

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, and splits the code that can
benefit from attribute offset optimizations into separate files. This does
NOT yet update the code itself - it just makes the code compile cleanly.
The performance should be comparable if not the same.
---
 contrib/amcheck/verify_nbtree.c               |    6 +
 src/backend/access/nbtree/README              |   28 +
 src/backend/access/nbtree/nbtdedup.c          |  300 +----
 src/backend/access/nbtree/nbtdedup_spec.c     |  317 +++++
 src/backend/access/nbtree/nbtinsert.c         |  579 +--------
 src/backend/access/nbtree/nbtinsert_spec.c    |  584 +++++++++
 src/backend/access/nbtree/nbtpage.c           |    1 +
 src/backend/access/nbtree/nbtree.c            |   37 +-
 src/backend/access/nbtree/nbtree_spec.c       |   69 +
 src/backend/access/nbtree/nbtsearch.c         | 1111 +---------------
 src/backend/access/nbtree/nbtsearch_spec.c    | 1123 +++++++++++++++++
 src/backend/access/nbtree/nbtsort.c           |  264 +---
 src/backend/access/nbtree/nbtsort_spec.c      |  280 ++++
 src/backend/access/nbtree/nbtsplitloc.c       |    3 +
 src/backend/access/nbtree/nbtutils.c          |  754 +----------
 src/backend/access/nbtree/nbtutils_spec.c     |  775 ++++++++++++
 src/backend/utils/sort/tuplesortvariants.c    |  156 +--
 .../utils/sort/tuplesortvariants_spec.c       |  175 +++
 src/include/access/nbtree.h                   |   44 +-
 src/include/access/nbtree_spec.h              |  183 +++
 src/include/access/nbtree_specfuncs.h         |   65 +
 src/tools/pginclude/cpluspluscheck            |    2 +
 src/tools/pginclude/headerscheck              |    2 +
 23 files changed, 3669 insertions(+), 3189 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.c
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.c
 create mode 100644 src/backend/access/nbtree/nbtree_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.c
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.c
 create mode 100644 src/backend/utils/sort/tuplesortvariants_spec.c
 create mode 100644 src/include/access/nbtree_spec.h
 create mode 100644 src/include/access/nbtree_specfuncs.h

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index e57625b75c..10ed67bffe 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2680,6 +2680,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 	BTStack		stack;
 	Buffer		lbuf;
 	bool		exists;
+	nbts_prep_ctx(NULL);
 
 	key = _bt_mkscankey(state->rel, itup);
 	Assert(key->heapkeyspace && key->scantid != NULL);
@@ -2780,6 +2781,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2843,6 +2845,7 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2867,6 +2870,7 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2906,6 +2910,7 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -3141,6 +3146,7 @@ static inline BTScanInsert
 bt_mkscankey_pivotsearch(Relation rel, IndexTuple itup)
 {
 	BTScanInsert skey;
+	nbts_prep_ctx(NULL);
 
 	skey = _bt_mkscankey(rel, itup);
 	skey->pivotsearch = true;
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 0f10141a2f..e9d0cf6ac1 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1084,6 +1084,34 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+Notes about nbtree specialization
+---------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes
+with variable length attributes, due to our inability to cache the offset
+of each attribute into an on-disk tuple. To combat this, we'd have to either
+fully deserialize the tuple, or maintain our offset into the tuple as we
+iterate over the tuple's fields.
+
+Keeping track of this offset also has a non-negligible overhead too, so we'd
+prefer to not have to keep track of these offsets when we can use the cache.
+By specializing performance-sensitive search functions for these specific
+index tuple shapes and calling those selectively, we can keep the performance
+of cacheable attribute offsets where that is applicable, while improving
+performance where we currently would see O(n_atts^2) time iterating on
+variable-length attributes.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also the default path, and is comparatively slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index d4db0b28f2..4589ade267 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,260 +22,14 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
-			   bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple and add it to our temp page (newpage).
-			 * Else add pending interval's base tuple to the temp page as-is.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place, when this page's newly allocated right sibling page
-				 * gets its first deduplication pass).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -316,6 +70,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 	TM_IndexDeleteOp delstate;
 	bool		neverdedup;
 	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	nbts_prep_ctx(rel);
 
 	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
 	newitemsz += sizeof(ItemIdData);
@@ -752,55 +507,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
new file mode 100644
index 0000000000..4b280de980
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -0,0 +1,317 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtdedup_spec.c
+ *	  Index shape-specialized functions for nbtdedup.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtdedup_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_do_singleval NBTS_FUNCTION(_bt_do_singleval)
+
+static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
+							 OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
+			   bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				minoff,
+				maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+				 _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple and add it to our temp page (newpage).
+			 * Else add pending interval's base tuple to the temp page as-is.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place, when this page's newly allocated right sibling page
+				 * gets its first deduplication pass).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+_bt_do_singleval(Relation rel, Page page, BTDedupState state,
+				 OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 39e7e9b731..3607bd418e 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,28 +30,16 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, Relation heaprel,
-								 BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
 static void _bt_stepright(Relation rel, Relation heaprel,
 						  BTInsertState insertstate, BTStack stack);
-static void _bt_insertonpg(Relation rel, Relation heaprel, BTScanInsert itup_key,
-						   Buffer buf,
-						   Buffer cbuf,
-						   BTStack stack,
-						   IndexTuple itup,
-						   Size itemsz,
-						   OffsetNumber newitemoff,
-						   int postingoff,
+static void _bt_insertonpg(Relation rel, Relation heaprel,
+						   BTScanInsert itup_key, Buffer buf, Buffer cbuf,
+						   BTStack stack, IndexTuple itup, Size itemsz,
+						   OffsetNumber newitemoff, int postingoff,
 						   bool split_only_page);
 static Buffer _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key,
 						Buffer buf, Buffer cbuf, OffsetNumber newitemoff,
@@ -75,313 +63,8 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, heapRel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
-					   stack, itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-			AttrNumber	cmpcol = 1;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
-							&cmpcol) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
-
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
-					  BT_WRITE, NULL);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -425,6 +108,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	bool		inposting = false;
 	bool		prevalldead = true;
 	int			curposti = 0;
+	nbts_prep_ctx(rel);
 
 	/* Assume unique until we find a duplicate */
 	*is_unique = true;
@@ -776,253 +460,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				AttrNumber	cmpcol = 1;
-
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
-					break;
-
-				_bt_stepright(rel, heapRel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			AttrNumber	cmpcol = 1;
-
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, heapRel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	{
-		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
-		Assert(P_RIGHTMOST(opaque) ||
-			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
-	}
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1506,6 +943,7 @@ _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
 	bool		newitemonleft,
 				isleaf,
 				isrightmost;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * origpage is the original page to be split.  leftpage is a temporary
@@ -2706,6 +2144,7 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 	BTScanInsert itup_key = insertstate->itup_key;
 	Page		page = BufferGetPage(buffer);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
+	nbts_prep_ctx(rel);
 
 	Assert(P_ISLEAF(opaque));
 	Assert(simpleonly || itup_key->heapkeyspace);
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
new file mode 100644
index 0000000000..6915f22839
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -0,0 +1,584 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtinsert_spec.c
+ *	  Index shape-specialized functions for nbtinsert.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtinsert_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_search_insert NBTS_FUNCTION(_bt_search_insert)
+#define _bt_findinsertloc NBTS_FUNCTION(_bt_findinsertloc)
+
+static BTStack _bt_search_insert(Relation rel, Relation heaprel,
+								 BTInsertState insertstate);
+static OffsetNumber _bt_findinsertloc(Relation rel,
+									  BTInsertState insertstate,
+									  bool checkingunique,
+									  bool indexUnchanged,
+									  BTStack stack,
+									  Relation heapRel);
+
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+_bt_doinsert(Relation rel, IndexTuple itup,
+			 IndexUniqueCheck checkUnique, bool indexUnchanged,
+			 Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = _bt_mkscankey(rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = _bt_search_insert(rel, heapRel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
+									   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
+					   stack, itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
+					  BT_WRITE, NULL);
+}
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+_bt_findinsertloc(Relation rel,
+				  BTInsertState insertstate,
+				  bool checkingunique,
+				  bool indexUnchanged,
+				  BTStack stack,
+				  Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				AttrNumber	cmpcol = 1;
+
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
+					break;
+
+				_bt_stepright(rel, heapRel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			AttrNumber	cmpcol = 1;
+
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, heapRel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
+
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 6558aea42b..7e8e4409c1 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1810,6 +1810,7 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 	bool		rightsib_empty;
 	Page		page;
 	BTPageOpaque opaque;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Save original leafbuf block number from caller.  Only deleted blocks
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 62bc9917f1..58f2fdba18 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,8 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -121,7 +123,7 @@ bthandler(PG_FUNCTION_ARGS)
 
 	amroutine->ambuild = btbuild;
 	amroutine->ambuildempty = btbuildempty;
-	amroutine->aminsert = btinsert;
+	amroutine->aminsert = btinsert_default;
 	amroutine->ambulkdelete = btbulkdelete;
 	amroutine->amvacuumcleanup = btvacuumcleanup;
 	amroutine->amcanreturn = btcanreturn;
@@ -155,6 +157,8 @@ btbuildempty(Relation index)
 	Buffer		metabuf;
 	Page		metapage;
 
+	nbt_opt_specialize(index);
+
 	/*
 	 * Initalize the metapage.
 	 *
@@ -180,33 +184,6 @@ btbuildempty(Relation index)
 	ReleaseBuffer(metabuf);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
@@ -348,6 +325,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -791,6 +770,8 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
 
+	nbt_opt_specialize(rel);
+
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
 		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
new file mode 100644
index 0000000000..6b766581ab
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -0,0 +1,69 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_spec.c
+ *	  Index shape-specialized functions for nbtree.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtree_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+_bt_specialize(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	NBTS_MAKE_CTX(rel);
+	/*
+	 * We can't directly address _bt_specialize here because it'd be macro-
+	 * expanded, nor can we utilize NBTS_SPECIALIZE_NAME here because it'd
+	 * try to call _bt_specialize, which would be an infinite recursive call.
+	 */
+	switch (__nbts_ctx) {
+		case NBTS_CTX_CACHED:
+			_bt_specialize_cached(rel);
+			break;
+		case NBTS_CTX_DEFAULT:
+			break;
+	}
+#else
+	rel->rd_indam->aminsert = btinsert;
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+btinsert(Relation rel, Datum *values, bool *isnull,
+		 ItemPointer ht_ctid, Relation heapRel,
+		 IndexUniqueCheck checkUnique,
+		 bool indexUnchanged,
+		 IndexInfo *indexInfo)
+{
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index a6998e48d8..d31bb8abdf 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -26,12 +26,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
-								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -48,6 +44,8 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -72,601 +70,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- *
- * heaprel must be provided by callers that pass access = BT_WRITE, since we
- * might need to allocate a new root page for caller -- see _bt_allocbuf.
- */
-BTStack
-_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
-		   int access, Snapshot snapshot)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-	char		tupdatabuf[BLCKSZ / 3];
-	AttrNumber	highkeycmpcol = 1;
-
-	/* heaprel must be set whenever _bt_allocbuf is reachable */
-	Assert(access == BT_READ || access == BT_WRITE);
-	Assert(access == BT_READ || heaprel != NULL);
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, heaprel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access, snapshot, &highkeycmpcol,
-							  (char *) tupdatabuf);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
-		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		highkeycmpcol = 1;
-
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split is
- * completed.  'heaprel' and 'stack' are only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * If the snapshot parameter is not NULL, "old snapshot" checking will take
- * place during the descent through the tree.  This is not needed when
- * positioning for an insert or delete, so NULL is used for those cases.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  Relation heaprel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  Snapshot snapshot,
-			  AttrNumber *comparecol,
-			  char *tupdatabuf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	Assert(!forupdate || heaprel != NULL);
-	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		AttrNumber	cmpcol = 1;
-
-		page = BufferGetPage(buf);
-		TestForOldSnapshot(snapshot, rel, page);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-		{
-			*comparecol = 1;
-			break;
-		}
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, heaprel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		/*
-		 * tupdatabuf is filled with the right seperator of the parent node.
-		 * This allows us to do a binary equality check between the parent
-		 * node's right seperator (which is < key) and this page's P_HIKEY.
-		 * If they equal, we can reuse the result of the parent node's
-		 * rightkey compare, which means we can potentially save a full key
-		 * compare (which includes indirect calls to attribute comparison
-		 * functions).
-		 * 
-		 * Without this, we'd on average use 3 full key compares per page before
-		 * we achieve full dynamic prefix bounds, but with this optimization
-		 * that is only 2.
-		 * 
-		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
-		 * we move right in the binary search on the page, this average equals
-		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
-		 */
-		if (!P_IGNORE(opaque) && *comparecol > 1)
-		{
-			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
-			IndexTuple buftuple = (IndexTuple) tupdatabuf;
-			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
-			{
-				char *dataptr = (char *) itup;
-
-				if (memcmp(dataptr + sizeof(IndexTupleData),
-						   tupdatabuf + sizeof(IndexTupleData),
-						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
-					break;
-			} else {
-				*comparecol = 1;
-			}
-		} else {
-			*comparecol = 1;
-		}
-
-		if (P_IGNORE(opaque) ||
-				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
-		{
-			*comparecol = 1;
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-		{
-			*comparecol = cmpcol;
-			break;
-		}
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * When called, the "highkeycmpcol" pointer argument is expected to contain the
- * AttrNumber of the first attribute that is not shared between scan key and
- * this page's high key, i.e. the first attribute that we have to compare
- * against the scan key.  The value will be updated by _bt_binsrch to contain
- * this same first column we'll need to compare against the scan key, but now
- * for the index tuple at the returned offset.  Valid values range from 1
- * (no shared prefix) to the number of key attributes + 1 (all index key
- * attributes are equal to the scan key).  See also _bt_compare, and
- * backend/access/nbtree/README for more info.
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf,
-			AttrNumber *highkeycmpcol)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-	/*
-	 * Prefix bounds, for the high/low offset's compare columns.
-	 * "highkeycmpcol" is the value for this page's high key (if any) or 1
-	 * (no established shared prefix)
-	 */
-	AttrNumber	highcmpcol = *highkeycmpcol,
-				lowcmpcol = 1;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We maintain highcmpcol and lowcmpcol to keep track of prefixes that
-	 * tuples share with the scan key, potentially allowing us to skip a
-	 * prefix in the midpoint comparison.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol); /* update prefix bounds */
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-		}
-	}
-
-	/* update the bounds at the caller */
-	*highkeycmpcol = highcmpcol;
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-				   AttrNumber highcmpcol)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-	AttrNumber	lowcmpcol = 1;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
-
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
  *
@@ -734,235 +137,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * NOTE: The "comparecol" argument must refer to the first attribute of the
- * index tuple of which the caller knows that it does not match the scan key:
- * this means 1 for "no known matching attributes", up to the number of key
- * attributes + 1 if the caller knows that all key attributes of the index
- * tuple match those of the scan key.  See backend/access/nbtree/README for
- * details.
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum,
-			AttrNumber *comparecol)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-
-	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-		{
-			*comparecol = i;
-			return result;
-		}
-
-		scankey++;
-	}
-
-	/*
-	 * All tuple attributes are equal to the scan key, only later attributes
-	 * could potentially not equal the scan key.
-	 */
-	*comparecol = ntupatts + 1;
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -1004,6 +178,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(rel);
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1638,280 +813,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2120,12 +1021,11 @@ static bool
 _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 {
 	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Relation	rel;
+	Relation	rel = scan->indexRelation;
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
-
-	rel = scan->indexRelation;
+	nbts_prep_ctx(rel);
 
 	if (ScanDirectionIsForward(dir))
 	{
@@ -2537,6 +1437,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	BTPageOpaque opaque;
 	OffsetNumber start;
 	BTScanPosItem *currItem;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Scan down to the leftmost or rightmost leaf page.  This is a simplified
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
new file mode 100644
index 0000000000..5f1ead2400
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -0,0 +1,1123 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsearch_spec.c
+ *	  Index shape-specialized functions for nbtsearch.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsearch_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_binsrch		NBTS_FUNCTION(_bt_binsrch)
+#define _bt_readpage	NBTS_FUNCTION(_bt_readpage)
+
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
+static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
+						 OffsetNumber offnum);
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ *
+ * heaprel must be provided by callers that pass access = BT_WRITE, since we
+ * might need to allocate a new root page for caller -- see _bt_allocbuf.
+ */
+BTStack
+_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
+		   int access, Snapshot snapshot)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
+
+	/* heaprel must be set whenever _bt_allocbuf is reachable */
+	Assert(access == BT_READ || access == BT_WRITE);
+	Assert(access == BT_READ || heaprel != NULL);
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, heaprel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
+							  stack_in, page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		highkeycmpcol = 1;
+
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split is
+ * completed.  'heaprel' and 'stack' are only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * If the snapshot parameter is not NULL, "old snapshot" checking will take
+ * place during the descent through the tree.  This is not needed when
+ * positioning for an insert or delete, so NULL is used for those cases.
+ */
+Buffer
+_bt_moveright(Relation rel,
+			  Relation heaprel,
+			  BTScanInsert key,
+			  Buffer buf,
+			  bool forupdate,
+			  BTStack stack,
+			  int access,
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	Assert(!forupdate || heaprel != NULL);
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		AttrNumber	cmpcol = 1;
+
+		page = BufferGetPage(buf);
+		TestForOldSnapshot(snapshot, rel, page);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
+			break;
+		}
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, heaprel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+			_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
+		{
+			*comparecol = 1;
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+		{
+			*comparecol = cmpcol;
+			break;
+		}
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * When called, the "highkeycmpcol" pointer argument is expected to contain the
+ * AttrNumber of the first attribute that is not shared between scan key and
+ * this page's high key, i.e. the first attribute that we have to compare
+ * against the scan key.  The value will be updated by _bt_binsrch to contain
+ * this same first column we'll need to compare against the scan key, but now
+ * for the index tuple at the returned offset.  Valid values range from 1
+ * (no shared prefix) to the number of key attributes + 1 (all index key
+ * attributes are equal to the scan key).  See also _bt_compare, and
+ * backend/access/nbtree/README for more info.
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+_bt_binsrch(Relation rel,
+			BTScanInsert key,
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+	/*
+	 * Prefix bounds, for the high/low offset's compare columns.
+	 * "highkeycmpcol" is the value for this page's high key (if any) or 1
+	 * (no established shared prefix)
+	 */
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We maintain highcmpcol and lowcmpcol to keep track of prefixes that
+	 * tuples share with the scan key, potentially allowing us to skip a
+	 * prefix in the midpoint comparison.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol); /* update prefix bounds */
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+		}
+	}
+
+	/* update the bounds at the caller */
+	*highkeycmpcol = highcmpcol;
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+	AttrNumber	lowcmpcol = 1;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * NOTE: The "comparecol" argument must refer to the first attribute of the
+ * index tuple of which the caller knows that it does not match the scan key:
+ * this means 1 for "no known matching attributes", up to the number of key
+ * attributes + 1 if the caller knows that all key attributes of the index
+ * tuple match those of the scan key.  See backend/access/nbtree/README for
+ * details.
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+_bt_compare(Relation rel,
+			BTScanInsert key,
+			Page page,
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+		{
+			*comparecol = i;
+			return result;
+		}
+
+		scankey++;
+	}
+
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index c2665fce41..8742716383 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,8 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -544,6 +544,7 @@ static void
 _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 {
 	BTWriteState wstate;
+	nbts_prep_ctx(btspool->index);
 
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
@@ -846,6 +847,7 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 	Size		pgspc;
 	Size		itupsz;
 	bool		isleaf;
+	nbts_prep_ctx(wstate->index);
 
 	/*
 	 * This is a handy place to check for cancel interrupts during the btree
@@ -1178,264 +1180,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			Assert(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
new file mode 100644
index 0000000000..368d6f244c
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -0,0 +1,280 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsort_spec.c
+ *	  Index shape-specialized functions for nbtsort.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsort_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_load NBTS_FUNCTION(_bt_load)
+
+static void _bt_load(BTWriteState *wstate,
+					 BTSpool *btspool, BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			Assert(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
+										 itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index 43b67893d9..db2da1e303 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -639,6 +639,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	ItemId		itemid;
 	IndexTuple	tup;
 	int			keepnatts;
+	nbts_prep_ctx(state->rel);
 
 	Assert(state->is_leaf && !state->is_rightmost);
 
@@ -945,6 +946,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 			   *rightinterval;
 	int			perfectpenalty;
 	int			indnkeyatts = IndexRelationGetNumberOfKeyAttributes(state->rel);
+	nbts_prep_ctx(state->rel);
 
 	/* Assume that alternative strategy won't be used for now */
 	*strategy = SPLIT_DEFAULT;
@@ -1137,6 +1139,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 {
 	IndexTuple	lastleft;
 	IndexTuple	firstright;
+	nbts_prep_ctx(state->rel);
 
 	if (!state->is_leaf)
 	{
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 7da499c4dd..37d644e9f3 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,10 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.c"
+#include "access/nbtree_spec.h"
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1220,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1703,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
new file mode 100644
index 0000000000..0288da22d6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -0,0 +1,775 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtutils_spec.c
+ *	  Index shape-specialized functions for nbtutils.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtutils_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_check_rowcompare	NBTS_FUNCTION(_bt_check_rowcompare)
+#define _bt_keep_natts			NBTS_FUNCTION(_bt_keep_natts)
+
+static bool _bt_check_rowcompare(ScanKey skey,
+								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+								 ScanDirection dir, bool *continuescan);
+static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
+							 IndexTuple firstright, BTScanInsert itup_key);
+
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+_bt_mkscankey(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+			  ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
+									 continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
+					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			 BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			   BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index 84442a93c5..d93839620d 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -61,10 +61,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int tuplen);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
-static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
-											Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static int	comparetup_index_hash_tiebreak(const SortTuple *a, const SortTuple *b,
@@ -140,6 +136,9 @@ typedef struct
 	int			datumTypeLen;
 } TuplesortDatumArg;
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesortvariants_spec.c"
+#include "access/nbtree_spec.h"
+
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
 					 int nkeys, AttrNumber *attNums,
@@ -228,6 +227,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 	MemoryContext oldcontext;
 	TuplesortClusterArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	Assert(indexRel->rd_rel->relam == BTREE_AM_OID);
 
@@ -340,6 +340,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	TuplesortIndexBTreeArg *arg;
 	MemoryContext oldcontext;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -475,6 +476,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 	MemoryContext oldcontext;
 	TuplesortIndexBTreeArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -1299,152 +1301,6 @@ removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
 	}
 }
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	SortSupport sortKey = base->sortKeys;
-	int32		compare;
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	return comparetup_index_btree_tiebreak(a, b, state);
-}
-
-static int
-comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
-								Tuplesortstate *state)
-{
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
-	SortSupport sortKey = base->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = base->nKeys;
-	tupDes = RelationGetDescr(arg->index.indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(arg->index.indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(arg->index.heapRel,
-									RelationGetRelationName(arg->index.indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
new file mode 100644
index 0000000000..705da09329
--- /dev/null
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -0,0 +1,175 @@
+/*-------------------------------------------------------------------------
+ *
+ * tuplesortvariants_spec.c
+ *	  Index shape-specialized functions for tuplesortvariants.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/tuplesortvariants_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define comparetup_index_btree NBTS_FUNCTION(comparetup_index_btree)
+#define comparetup_index_btree_tiebreak NBTS_FUNCTION(comparetup_index_btree_tiebreak)
+
+static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+								   Tuplesortstate *state);
+static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
+											Tuplesortstate *state);
+
+static int
+comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+					   Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	SortSupport sortKey = base->sortKeys;
+	int32		compare;
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	return comparetup_index_btree_tiebreak(a, b, state);
+}
+
+static int
+comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
+								Tuplesortstate *state)
+{	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
+	SortSupport sortKey = base->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	Datum		datum1,
+				datum2;
+	bool		isnull1,
+				isnull2;
+
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = base->nKeys;
+	tupDes = RelationGetDescr(arg->index.indexRel);
+
+	if (sortKey->abbrev_converter)
+	{
+		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
+
+		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
+												datum2, isnull2,
+												sortKey);
+		if (compare != 0)
+			return compare;
+	}
+
+	/* they are equal, so we only need to examine one null flag */
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	sortKey++;
+	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	{
+		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+
+		compare = ApplySortComparator(datum1, isnull1,
+									  datum2, isnull2,
+									  sortKey);
+		if (compare != 0)
+			return compare;		/* done when we find unequal attributes */
+
+		/* they are equal, so we only need to examine one null flag */
+		if (isnull1)
+			equal_hasnull = true;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(arg->index.indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(arg->index.heapRel,
+									   RelationGetRelationName(arg->index.indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 11f4184107..d1bbc4d2a8 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1121,15 +1121,27 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+typedef enum NBTS_CTX {
+	NBTS_CTX_CACHED, 
+	NBTS_CTX_DEFAULT, /* fallback */
+} NBTS_CTX;
+
+static inline NBTS_CTX _nbt_spec_context(Relation irel)
+{
+	if (!PointerIsValid(irel))
+		return NBTS_CTX_DEFAULT;
+
+	return NBTS_CTX_CACHED;
+}
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
+#include "nbtree_spec.h"
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1160,8 +1172,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
-						   Size newitemsz, bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1177,9 +1187,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Relation heaprel, Buffer lbuf,
 							 BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, Relation heaprel, BTStack stack,
@@ -1230,16 +1237,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
-						  Buffer *bufP, int access, Snapshot snapshot);
-extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
-							Buffer buf, bool forupdate, BTStack stack,
-							int access, Snapshot snapshot,
-							AttrNumber *comparecol, char *tupdatabuf);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-									   AttrNumber highcmpcol);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
-						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
@@ -1248,7 +1245,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1256,8 +1252,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1270,10 +1264,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
new file mode 100644
index 0000000000..fa38b09c6e
--- /dev/null
+++ b/src/include/access/nbtree_spec.h
@@ -0,0 +1,183 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ * - nbts_context(irel)
+ *   Constructs a context that is used to call specialized functions.
+ *   Note that this is unneeded in paths that are inaccessible to unspecialized
+ *   code paths (i.e. code included through nbtree_spec.h), because that
+ *   always calls the optimized functions directly.
+ */
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+#define NBTS_CTX_NAME __nbts_ctx
+
+/* contextual specializations */
+#define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
+#define NBTS_SPECIALIZE_NAME(name) ( \
+	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	) \
+)
+
+/* how do we make names? */
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define nbt_opt_specialize(rel) \
+do { \
+	Assert(PointerIsValid(rel)); \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
+	{ \
+		nbts_prep_ctx(rel); \
+		_bt_specialize(rel); \
+	} \
+} while (false)
+
+/*
+ * Protections against multiple inclusions - the definition of this macro is
+ * different for files included with the templating mechanism vs the users
+ * of this template, so redefine these macros at top and bottom.
+ */
+#ifdef NBTS_FUNCTION
+#undef NBTS_FUNCTION
+#endif
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+/* While specializing, the context is the local context */
+#ifdef nbts_prep_ctx
+#undef nbts_prep_ctx
+#endif
+#define nbts_prep_ctx(rel)
+
+/*
+ * Specialization 1: CACHED
+ *
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) do {} while (false)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_SPECIALIZING_CACHED
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * Specialization 2: DEFAULT
+ *
+ * "Default", externally accessible, not so optimized functions
+ */
+
+/* Only the default context may need to specialize in some cases, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * All next uses of nbts_prep_ctx are in non-templated code, so here we make
+ * sure we actually create the context.
+ */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+/*
+ * from here on all NBTS_FUNCTIONs are from specialized function names that
+ * are being called. Change the result of those macros from a direct call
+ * call to a conditional call to the right place, depending on the correct
+ * context.
+ */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) NBTS_SPECIALIZE_NAME(name)
+
+#undef NBT_SPECIALIZE_FILE
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
new file mode 100644
index 0000000000..b87f5bf802
--- /dev/null
+++ b/src/include/access/nbtree_specfuncs.h
@@ -0,0 +1,65 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+#define _bt_specialize		NBTS_FUNCTION(_bt_specialize)
+#define btinsert			NBTS_FUNCTION(btinsert)
+#define _bt_dedup_pass		NBTS_FUNCTION(_bt_dedup_pass)
+#define _bt_doinsert		NBTS_FUNCTION(_bt_doinsert)
+#define _bt_search			NBTS_FUNCTION(_bt_search)
+#define _bt_moveright		NBTS_FUNCTION(_bt_moveright)
+#define _bt_binsrch_insert	NBTS_FUNCTION(_bt_binsrch_insert)
+#define _bt_compare			NBTS_FUNCTION(_bt_compare)
+#define _bt_mkscankey		NBTS_FUNCTION(_bt_mkscankey)
+#define _bt_checkkeys		NBTS_FUNCTION(_bt_checkkeys)
+#define _bt_truncate		NBTS_FUNCTION(_bt_truncate)
+#define _bt_keep_natts_fast	NBTS_FUNCTION(_bt_keep_natts_fast)
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void _bt_specialize(Relation rel);
+
+extern bool btinsert(Relation rel, Datum *values, bool *isnull,
+					 ItemPointer ht_ctid, Relation heapRel,
+					 IndexUniqueCheck checkUnique, bool indexUnchanged,
+					 struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
+						   Size newitemsz, bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool _bt_doinsert(Relation rel, IndexTuple itup,
+						 IndexUniqueCheck checkUnique, bool indexUnchanged,
+						 Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
+						  Buffer *bufP, int access, Snapshot snapshot);
+extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
+							Buffer buf, bool forupdate, BTStack stack,
+							int access, Snapshot snapshot,
+							AttrNumber *comparecol, char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
+extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+						  ScanDirection dir, bool *continuescan);
+extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright, BTScanInsert itup_key);
+extern int _bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright);
diff --git a/src/tools/pginclude/cpluspluscheck b/src/tools/pginclude/cpluspluscheck
index 4e09c4686b..e504a2f114 100755
--- a/src/tools/pginclude/cpluspluscheck
+++ b/src/tools/pginclude/cpluspluscheck
@@ -116,6 +116,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
diff --git a/src/tools/pginclude/headerscheck b/src/tools/pginclude/headerscheck
index 8dee1b5670..101888c806 100755
--- a/src/tools/pginclude/headerscheck
+++ b/src/tools/pginclude/headerscheck
@@ -111,6 +111,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
-- 
2.40.1

From 36800c5124b34e5ba105901de5ba9a0ed9c18d4b Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Tue, 10 Jan 2023 21:45:44 +0100
Subject: [PATCH v12 1/6] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also have those prefixing attributes that equal the
scankey.

We cannot generally propagate this information to _binsrch on
lower pages, as this downstream page may have concurrently split
and/or have merged with its deleted left neighbour (see [0]),
which moves the keyspace of the linked page. We thus can only
trust the current state of this current page for this optimization,
which means we must validate this state each time we open the page.

Although this limits the overall applicability of the
performance improvement, it still allows for a nice performance
improvement in most cases where initial columns have many
duplicate values and a compare function that is not cheap.

As an exception to the above rule, most of the time a pages'
highkey is equal to the right seperator on the parent page due to
how btree splits are done. By storing this right seperator from
the parent page and then validating that the highkey of the child
page contains the exact same data, we can restore the right prefix
bound without having to call the relatively expensive _bt_compare.

In the worst-case scenario of a concurrent page split, we'd still
have to validate the full key, but that doesn't happen very often
when compared to the number of times we descend the btree.
---
 contrib/amcheck/verify_nbtree.c       |  17 +--
 src/backend/access/nbtree/README      |  43 ++++++++
 src/backend/access/nbtree/nbtinsert.c |  34 ++++--
 src/backend/access/nbtree/nbtsearch.c | 145 +++++++++++++++++++++++---
 src/include/access/nbtree.h           |   9 +-
 5 files changed, 214 insertions(+), 34 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 94a9759322..e57625b75c 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2701,6 +2701,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2710,13 +2711,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2778,6 +2779,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2788,7 +2790,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2840,10 +2842,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2863,10 +2866,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2901,13 +2905,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 52e646c7f7..0f10141a2f 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,49 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+saving the indirect function calls in the compare operation.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by a parent page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. [2,3) to [1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+There is positive news, though: A page split will put a binary copy of the
+page's highkey in the parent page. This means that we usually can reuse
+the compare result of the parent page's downlink's right sibling when we
+discover that their representation is binary equal. In general this will
+be the case, as only in concurrent page splits and deletes the downlink
+may not point to the page with the correct highkey bound (_bt_moveright
+only rarely actually moves right).
+
+To implement this, we copy the downlink's right differentiator key into a
+temporary buffer, which is then compared against the child pages' highkey.
+If they match, we reuse the compare result (plus prefix) we had for it from
+the parent page, if not, we need to do a full _bt_compare. Because memcpy +
+memcmp is cheap compared to _bt_compare, and because it's quite unlikely
+that we guess wrong this speeds up our _bt_moveright code (at cost of some
+stack memory in _bt_search and some overhead in case of a wrong prediction)
+
+Now that we have prefix bounds on the highest value of a page, the
+_bt_binsrch procedure will use this result as a rightmost prefix compare,
+and for each step in the binary search (that does not compare less than the
+insert key) improve the equal-prefix bounds.
+
+Using the above optimization, we now (on average) only need 2 full key
+compares per page (plus ceil(log2(ntupsperpage)) single-attribute compares),
+as opposed to the ceil(log2(ntupsperpage)) + 1 of a naive implementation;
+a significant improvement.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index d33f814a93..39e7e9b731 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -328,6 +328,7 @@ _bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -346,7 +347,8 @@ _bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -440,7 +442,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = _bt_binsrch_insert(rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -450,6 +452,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -485,7 +489,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(_bt_compare(rel, itup_key, page, offset, &cmpcol) < 0);
 				break;
 			}
 
@@ -510,7 +514,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (_bt_compare(rel, itup_key, page, offset, &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -720,11 +724,12 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -867,6 +872,8 @@ _bt_findinsertloc(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
+
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -884,7 +891,7 @@ _bt_findinsertloc(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, heapRel, insertstate, stack);
@@ -937,6 +944,8 @@ _bt_findinsertloc(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
+
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -967,7 +976,7 @@ _bt_findinsertloc(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -982,10 +991,13 @@ _bt_findinsertloc(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -1004,7 +1016,7 @@ _bt_findinsertloc(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index 3230b3b894..a6998e48d8 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -26,7 +26,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
 static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
@@ -102,6 +103,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
 
 	/* heaprel must be set whenever _bt_allocbuf is reachable */
 	Assert(access == BT_READ || access == BT_WRITE);
@@ -138,7 +141,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * opportunity to finish splits of internal pages too.
 		 */
 		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access, snapshot);
+							  stack_in, page_access, snapshot, &highkeycmpcol,
+							  (char *) tupdatabuf);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -150,12 +154,15 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -189,6 +196,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		highkeycmpcol = 1;
+
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -199,7 +208,7 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
-							  snapshot);
+							  snapshot, &highkeycmpcol, (char *) tupdatabuf);
 	}
 
 	return stack_in;
@@ -248,13 +257,16 @@ _bt_moveright(Relation rel,
 			  bool forupdate,
 			  BTStack stack,
 			  int access,
-			  Snapshot snapshot)
+			  Snapshot snapshot,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
 	Assert(!forupdate || heaprel != NULL);
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
 
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
@@ -277,12 +289,17 @@ _bt_moveright(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		TestForOldSnapshot(snapshot, rel, page);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -308,14 +325,55 @@ _bt_moveright(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
 		{
+			*comparecol = 1;
 			/* step right one page */
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -341,6 +399,16 @@ _bt_moveright(Relation rel,
  * right place to descend to be sure we find all leaf keys >= given scankey
  * (or leaf keys > given scankey when nextkey is true).
  *
+ * When called, the "highkeycmpcol" pointer argument is expected to contain the
+ * AttrNumber of the first attribute that is not shared between scan key and
+ * this page's high key, i.e. the first attribute that we have to compare
+ * against the scan key.  The value will be updated by _bt_binsrch to contain
+ * this same first column we'll need to compare against the scan key, but now
+ * for the index tuple at the returned offset.  Valid values range from 1
+ * (no shared prefix) to the number of key attributes + 1 (all index key
+ * attributes are equal to the scan key).  See also _bt_compare, and
+ * backend/access/nbtree/README for more info.
+ *
  * This procedure is not responsible for walking right, it just examines
  * the given page.  _bt_binsrch() has no lock or refcount side effects
  * on the buffer.
@@ -348,7 +416,8 @@ _bt_moveright(Relation rel,
 static OffsetNumber
 _bt_binsrch(Relation rel,
 			BTScanInsert key,
-			Buffer buf)
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -356,6 +425,13 @@ _bt_binsrch(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	/*
+	 * Prefix bounds, for the high/low offset's compare columns.
+	 * "highkeycmpcol" is the value for this page's high key (if any) or 1
+	 * (no established shared prefix)
+	 */
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -388,6 +464,10 @@ _bt_binsrch(Relation rel,
 	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
 	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
 	 *
+	 * We maintain highcmpcol and lowcmpcol to keep track of prefixes that
+	 * tuples share with the scan key, potentially allowing us to skip a
+	 * prefix in the midpoint comparison.
+	 *
 	 * We can fall out when high == low.
 	 */
 	high++;						/* establish the loop invariant for high */
@@ -397,17 +477,27 @@ _bt_binsrch(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol); /* update prefix bounds */
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
 
+	/* update the bounds at the caller */
+	*highkeycmpcol = highcmpcol;
+
 	/*
 	 * At this point we have high == low, but be careful: they could point
 	 * past the last slot on the page.
@@ -450,7 +540,8 @@ _bt_binsrch(Relation rel,
  * list split).
  */
 OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -460,6 +551,7 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -510,16 +602,22 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
+
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -654,6 +752,13 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
  * matching TID in the posting tuple, which caller must handle
  * themselves (e.g., by splitting the posting list tuple).
  *
+ * NOTE: The "comparecol" argument must refer to the first attribute of the
+ * index tuple of which the caller knows that it does not match the scan key:
+ * this means 1 for "no known matching attributes", up to the number of key
+ * attributes + 1 if the caller knows that all key attributes of the index
+ * tuple match those of the scan key.  See backend/access/nbtree/README for
+ * details.
+ *
  * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
  * "minus infinity": this routine will always claim it is less than the
  * scankey.  The actual key value stored is explicitly truncated to 0
@@ -667,7 +772,8 @@ int32
 _bt_compare(Relation rel,
 			BTScanInsert key,
 			Page page,
-			OffsetNumber offnum)
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -707,8 +813,9 @@ _bt_compare(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
 	{
 		Datum		datum;
 		bool		isNull;
@@ -752,11 +859,20 @@ _bt_compare(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = i;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
@@ -887,6 +1003,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	AttrNumber	cmpcol = 1;
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1415,7 +1532,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = _bt_binsrch(rel, &inskey, buf, &cmpcol);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 8891fa7973..11f4184107 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1234,9 +1234,12 @@ extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
 						  Buffer *bufP, int access, Snapshot snapshot);
 extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
 							Buffer buf, bool forupdate, BTStack stack,
-							int access, Snapshot snapshot);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
+							int access, Snapshot snapshot,
+							AttrNumber *comparecol, char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost,
-- 
2.40.1

From 26e4beb6d6acf6c4e5ec08df44ff7a4898c0f887 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 13 Jan 2023 15:42:41 +0100
Subject: [PATCH v12 6/6] btree specialization for variable-length
 multi-attribute keys

The default code path is relatively slow at O(n^2), so with multiple
attributes we accept the increased startup cost in favour of lower
costs for later attributes.

Note that this will only be used for indexes that use at least one
variable-length key attribute (except as last key attribute in specific
cases).
---
 src/backend/access/nbtree/README        |   6 +-
 src/backend/access/nbtree/nbtree_spec.c |   3 +
 src/include/access/itup_attiter.h       | 199 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  11 +-
 src/include/access/nbtree_spec.h        |  48 +++++-
 5 files changed, 258 insertions(+), 9 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index e90e24cb70..0c45288e61 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1105,14 +1105,12 @@ performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
  - indexes with only a single key attribute
+ - multi-column indexes that cannot pre-calculate the offsets of all key
+   attributes in the tuple data section
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
 
-Future work will optimize for multi-column indexes that don't benefit
-from the attcacheoff optimization by improving on the O(n^2) nature of
-index_getattr through storing attribute offsets.
-
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 21635397ed..699197dfa7 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_UNCACHED:
+			_bt_specialize_uncached(rel);
+			break;
 		case NBTS_CTX_SINGLE_KEYATT:
 			_bt_specialize_single_keyatt(rel);
 			break;
diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..c8fb6954bc
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,199 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup_attiter.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+#include "varatt.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 72fbf3a4c6..204e349872 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1123,18 +1124,26 @@ typedef struct BTOptions
 
 typedef enum NBTS_CTX {
 	NBTS_CTX_SINGLE_KEYATT, 
+	NBTS_CTX_UNCACHED,
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	AttrNumber	nKeyAtts;
+
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
-	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+	nKeyAtts = IndexRelationGetNumberOfKeyAttributes(irel);
+
+	if (nKeyAtts == 1)
 		return NBTS_CTX_SINGLE_KEYATT;
 
+	if (TupleDescAttr(irel->rd_att, nKeyAtts - 1)->attcacheoff < -1)
+		return NBTS_CTX_UNCACHED;
+
 	return NBTS_CTX_CACHED;
 }
 
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 8e476c300d..efed9824e7 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -45,6 +45,7 @@
  * Macros used in the nbtree specialization code.
  */
 #define NBTS_TYPE_SINGLE_KEYATT single_keyatt
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -53,8 +54,10 @@
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
 	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
-		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		(NBTS_CTX_NAME) == NBTS_CTX_UNCACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED)) : ( \
+			(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+				NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+			) \
 		) \
 	) \
 )
@@ -69,8 +72,11 @@ do { \
 	Assert(PointerIsValid(rel)); \
 	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
 	{ \
-		nbts_prep_ctx(rel); \
-		_bt_specialize(rel); \
+		PopulateTupleDescCacheOffsets((rel)->rd_att); \
+		{ \
+			nbts_prep_ctx(rel); \
+			_bt_specialize(rel); \
+		} \
 	} \
 } while (false)
 
@@ -216,6 +222,40 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All next uses of nbts_prep_ctx are in non-templated code, so here we make
  * sure we actually create the context.
-- 
2.40.1

From 34c25502bfb68a42ce16e9a335d1d44c29ab9d04 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 12 Jan 2023 21:34:36 +0100
Subject: [PATCH v13 5/6] Add an attcacheoff-populating function

It populates attcacheoff-capable attributes with the correct offset,
and fills attributes whose offset is uncacheable with an 'uncacheable'
indicator value; as opposed to -1 which signals "unknown".

This allows users of the API to remove redundant cycles that try to
cache the offset of attributes - instead of O(N-attrs) operations, this
one only requires a O(1) check.
---
 src/backend/access/common/tupdesc.c | 111 ++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |   2 +
 2 files changed, 113 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index 7c5c390503..b3f543cd83 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -927,3 +927,114 @@ BuildDescFromLists(List *names, List *types, List *typmods, List *collations)
 
 	return desc;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid offset value.
+ *
+ * Populates attcacheoff with a negative cache value when no offset
+ * can be calculated (due to e.g. variable length attributes).
+ * The negative value is a value relative to the last cacheable attribute
+ *   attcacheoff = -1 - (thisattno - cachedattno)
+ * so that the last attribute with cached offset can be found with
+ *   cachedattno = attcacheoff + 1 + thisattno
+ *   
+ * The value returned is the AttrNumber of the last (1-based) attribute that
+ * had its offset cached.
+ * 
+ * When the TupleDesc has 0 attributes, it returns 0.
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	currAttNo, lastCachedAttNo;
+
+	if (numberOfAttributes == 0)
+		return 0;
+
+	/* Non-negative value: this attribute is cached */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff >= 0)
+		return (AttrNumber) desc->natts;
+	/*
+	 * Attribute has been filled with relative offset to last cached value, but
+	 * it itself is unreachable.
+	 */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+		return (AttrNumber) (TupleDescAttr(desc, desc->natts - 1)->attcacheoff + 1 + desc->natts);
+
+	/* last attribute of the tupledesc may or may not support attcacheoff */
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	currAttNo = 1;
+	/*
+	 * Other code may have populated the value previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (currAttNo < numberOfAttributes &&
+		   TupleDescAttr(desc, currAttNo)->attcacheoff >= 0)
+		currAttNo++;
+
+	/*
+	 * Cache offset is undetermined. Start calculating offsets if possible.
+	 * 
+	 * When we exit this block, currAttNo will point at the first uncacheable
+	 * attribute, or past the end of the attribute array.
+	 */
+	if (currAttNo < numberOfAttributes &&
+		TupleDescAttr(desc, currAttNo)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, currAttNo - 1);
+		int32 off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (currAttNo < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, currAttNo);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+					{
+						att->attcacheoff = off;
+						currAttNo++;
+					}
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				currAttNo++;
+			}
+		}
+	}
+
+	Assert(currAttNo == numberOfAttributes || (
+		currAttNo < numberOfAttributes
+		&& TupleDescAttr(desc, (currAttNo - 1))->attcacheoff >= 0
+		&& TupleDescAttr(desc, currAttNo)->attcacheoff == -1
+	));
+	/*
+	 * No cacheable offsets left. Fill the rest with negative cache values,
+	 * but return the latest cached offset.
+	 */
+	lastCachedAttNo = currAttNo;
+
+	while (currAttNo < numberOfAttributes)
+	{
+		TupleDescAttr(desc, currAttNo)->attcacheoff = -1 - (currAttNo - lastCachedAttNo);
+		currAttNo++;
+	}
+
+	return lastCachedAttNo;
+}
\ No newline at end of file
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index b4286cf922..2673f2d0f3 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescForRelation(List *schema);
 
 extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.40.1

From 1b096923670ebb4f17743ba007c0b2e168104fd7 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Tue, 10 Jan 2023 21:45:44 +0100
Subject: [PATCH v13 1/6] Implement dynamic prefix compression in nbtree

Because tuples are ordered on the page, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also have those prefixing attributes that equal the
scankey.

We cannot generally propagate this information to _binsrch on
lower pages, as this downstream page may have concurrently split
and/or have merged with its deleted left neighbour (see [0]),
which moves the keyspace of the linked page. We thus can only
trust the current state of this current page for this optimization,
which means we must validate this state each time we open the page.

Although this limits the overall applicability of the
performance improvement, it still allows for a nice performance
improvement in most cases where initial columns have many
duplicate values and a compare function that is not cheap.

As an exception to the above rule, most of the time a pages'
highkey is equal to the right seperator on the parent page due to
how btree splits are done. By storing this right seperator from
the parent page and then validating that the highkey of the child
page contains the exact same data, we can restore the right prefix
bound without having to call the relatively expensive _bt_compare.

In the worst-case scenario of a concurrent page split, we'd still
have to validate the full key, but that doesn't happen very often
when compared to the number of times we descend the btree.
---
 contrib/amcheck/verify_nbtree.c       |  17 +--
 src/backend/access/nbtree/README      |  43 ++++++++
 src/backend/access/nbtree/nbtinsert.c |  34 ++++--
 src/backend/access/nbtree/nbtsearch.c | 146 +++++++++++++++++++++++---
 src/include/access/nbtree.h           |   9 +-
 5 files changed, 215 insertions(+), 34 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index dbb83d80f8..e5cab3e3a9 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2701,6 +2701,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	cmpcol = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -2710,13 +2711,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &cmpcol) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -2778,6 +2779,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
@@ -2788,7 +2790,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -2840,10 +2842,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &cmpcol);
 
 	return cmp <= 0;
 }
@@ -2863,10 +2866,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -2901,13 +2905,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	cmpcol = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &cmpcol);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 52e646c7f7..0f10141a2f 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,49 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+Notes about dynamic prefix truncation
+-------------------------------------
+
+Because NBTrees have a sorted keyspace, when we have determined that some
+prefixing columns of tuples on both sides of the tuple that is being
+compared are equal to the scankey, then the current tuple must also share
+this prefix with the scankey. This allows us to skip comparing those columns,
+saving the indirect function calls in the compare operation.
+
+We can only use this constraint if we have proven this information while we
+hold a pin on the page, so this is only useful on the page level: Concurrent
+page deletions and splits may have moved the keyspace of the page referenced
+by a parent page to the right. If we re-used high- and low-column-prefixes,
+we would not be able to detect a change of keyspace from e.g. [2,3) to [1,2),
+and subsequently return invalid results. This race condition can only be
+prevented by re-establishing the prefix-equal-columns for each page.
+
+There is positive news, though: A page split will put a binary copy of the
+page's highkey in the parent page. This means that we usually can reuse
+the compare result of the parent page's downlink's right sibling when we
+discover that their representation is binary equal. In general this will
+be the case, as only in concurrent page splits and deletes the downlink
+may not point to the page with the correct highkey bound (_bt_moveright
+only rarely actually moves right).
+
+To implement this, we copy the downlink's right differentiator key into a
+temporary buffer, which is then compared against the child pages' highkey.
+If they match, we reuse the compare result (plus prefix) we had for it from
+the parent page, if not, we need to do a full _bt_compare. Because memcpy +
+memcmp is cheap compared to _bt_compare, and because it's quite unlikely
+that we guess wrong this speeds up our _bt_moveright code (at cost of some
+stack memory in _bt_search and some overhead in case of a wrong prediction)
+
+Now that we have prefix bounds on the highest value of a page, the
+_bt_binsrch procedure will use this result as a rightmost prefix compare,
+and for each step in the binary search (that does not compare less than the
+insert key) improve the equal-prefix bounds.
+
+Using the above optimization, we now (on average) only need 2 full key
+compares per page (plus ceil(log2(ntupsperpage)) single-attribute compares),
+as opposed to the ceil(log2(ntupsperpage)) + 1 of a naive implementation;
+a significant improvement.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 9cff4f2931..8f602ab2d6 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -328,6 +328,7 @@ _bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -346,7 +347,8 @@ _bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -440,7 +442,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = _bt_binsrch_insert(rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -450,6 +452,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -485,7 +489,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(_bt_compare(rel, itup_key, page, offset, &cmpcol) < 0);
 				break;
 			}
 
@@ -510,7 +514,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (_bt_compare(rel, itup_key, page, offset, &cmpcol) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -720,11 +724,12 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpcol = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -867,6 +872,8 @@ _bt_findinsertloc(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpcol = 1;
+
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -884,7 +891,7 @@ _bt_findinsertloc(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
 					break;
 
 				_bt_stepright(rel, heapRel, insertstate, stack);
@@ -937,6 +944,8 @@ _bt_findinsertloc(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpcol = 1;
+
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -967,7 +976,7 @@ _bt_findinsertloc(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -982,10 +991,13 @@ _bt_findinsertloc(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
 
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -1004,7 +1016,7 @@ _bt_findinsertloc(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index 17ad89749d..44a09ced98 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -26,7 +26,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
 static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
@@ -98,6 +99,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
 
 	/* heaprel must be set whenever _bt_allocbuf is reachable */
 	Assert(access == BT_READ || access == BT_WRITE);
@@ -134,7 +137,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * opportunity to finish splits of internal pages too.
 		 */
 		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access);
+							  stack_in, page_access, &highkeycmpcol,
+							  (char *) tupdatabuf);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -146,12 +150,15 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -185,6 +192,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		highkeycmpcol = 1;
+
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -194,7 +203,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * but before we acquired a write lock.  If it has, we may need to
 		 * move right to its new sibling.  Do that.
 		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE);
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
+							  &highkeycmpcol, (char *) tupdatabuf);
 	}
 
 	return stack_in;
@@ -238,13 +248,16 @@ _bt_moveright(Relation rel,
 			  Buffer buf,
 			  bool forupdate,
 			  BTStack stack,
-			  int access)
+			  int access,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
 {
 	Page		page;
 	BTPageOpaque opaque;
 	int32		cmpval;
 
 	Assert(!forupdate || heaprel != NULL);
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
 
 	/*
 	 * When nextkey = false (normal case): if the scan key that brought us to
@@ -267,11 +280,16 @@ _bt_moveright(Relation rel,
 
 	for (;;)
 	{
+		AttrNumber	cmpcol = 1;
+
 		page = BufferGetPage(buf);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -297,14 +315,55 @@ _bt_moveright(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
 		{
+			*comparecol = 1;
 			/* step right one page */
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			*comparecol = cmpcol;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -330,6 +389,16 @@ _bt_moveright(Relation rel,
  * right place to descend to be sure we find all leaf keys >= given scankey
  * (or leaf keys > given scankey when nextkey is true).
  *
+ * When called, the "highkeycmpcol" pointer argument is expected to contain the
+ * AttrNumber of the first attribute that is not shared between scan key and
+ * this page's high key, i.e. the first attribute that we have to compare
+ * against the scan key.  The value will be updated by _bt_binsrch to contain
+ * this same first column we'll need to compare against the scan key, but now
+ * for the index tuple at the returned offset.  Valid values range from 1
+ * (no shared prefix) to the number of key attributes + 1 (all index key
+ * attributes are equal to the scan key).  See also _bt_compare, and
+ * backend/access/nbtree/README for more info.
+ *
  * This procedure is not responsible for walking right, it just examines
  * the given page.  _bt_binsrch() has no lock or refcount side effects
  * on the buffer.
@@ -337,7 +406,8 @@ _bt_moveright(Relation rel,
 static OffsetNumber
 _bt_binsrch(Relation rel,
 			BTScanInsert key,
-			Buffer buf)
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -345,6 +415,13 @@ _bt_binsrch(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	/*
+	 * Prefix bounds, for the high/low offset's compare columns.
+	 * "highkeycmpcol" is the value for this page's high key (if any) or 1
+	 * (no established shared prefix)
+	 */
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -377,6 +454,10 @@ _bt_binsrch(Relation rel,
 	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
 	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
 	 *
+	 * We maintain highcmpcol and lowcmpcol to keep track of prefixes that
+	 * tuples share with the scan key, potentially allowing us to skip a
+	 * prefix in the midpoint comparison.
+	 *
 	 * We can fall out when high == low.
 	 */
 	high++;						/* establish the loop invariant for high */
@@ -386,17 +467,27 @@ _bt_binsrch(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol); /* update prefix bounds */
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
+		{
 			high = mid;
+			highcmpcol = cmpcol;
+		}
 	}
 
+	/* update the bounds at the caller */
+	*highkeycmpcol = highcmpcol;
+
 	/*
 	 * At this point we have high == low, but be careful: they could point
 	 * past the last slot on the page.
@@ -439,7 +530,8 @@ _bt_binsrch(Relation rel,
  * list split).
  */
 OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -449,6 +541,7 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowcmpcol = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -499,16 +592,22 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
 		else
 		{
 			high = mid;
+			highcmpcol = cmpcol;
+
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -643,6 +742,13 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
  * matching TID in the posting tuple, which caller must handle
  * themselves (e.g., by splitting the posting list tuple).
  *
+ * NOTE: The "comparecol" argument must refer to the first attribute of the
+ * index tuple of which the caller knows that it does not match the scan key:
+ * this means 1 for "no known matching attributes", up to the number of key
+ * attributes + 1 if the caller knows that all key attributes of the index
+ * tuple match those of the scan key.  See backend/access/nbtree/README for
+ * details.
+ *
  * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
  * "minus infinity": this routine will always claim it is less than the
  * scankey.  The actual key value stored is explicitly truncated to 0
@@ -656,7 +762,8 @@ int32
 _bt_compare(Relation rel,
 			BTScanInsert key,
 			Page page,
-			OffsetNumber offnum)
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -696,8 +803,9 @@ _bt_compare(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
 	{
 		Datum		datum;
 		bool		isNull;
@@ -741,11 +849,20 @@ _bt_compare(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*comparecol = i;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
@@ -876,6 +993,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	AttrNumber	cmpcol = 1;
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1403,7 +1521,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	offnum = _bt_binsrch(rel, &inskey, buf, &cmpcol);
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index f5c66964ca..0579120693 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1234,9 +1234,12 @@ extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
 						  Buffer *bufP, int access);
 extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
 							Buffer buf, bool forupdate, BTStack stack,
-							int access);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
+							int access, AttrNumber *comparecol,
+							char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost);
-- 
2.40.1

From ddacd699417ac50e34e569138a62f27a11ea163e Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 20:04:56 +0100
Subject: [PATCH v13 4/6] Optimize nbts_attiter for nkeyatts==1 btrees

This removes the index_getattr_nocache call path, which has significant overhead, and uses constant 0 offset.
---
 src/backend/access/nbtree/README        |  1 +
 src/backend/access/nbtree/nbtree_spec.c |  3 ++
 src/include/access/nbtree.h             | 35 ++++++++++++++++
 src/include/access/nbtree_spec.h        | 56 ++++++++++++++++++++++++-
 4 files changed, 93 insertions(+), 2 deletions(-)

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index e9d0cf6ac1..e90e24cb70 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1104,6 +1104,7 @@ in the index AM to call the specialized functions, increasing the
 performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
+ - indexes with only a single key attribute
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 6b766581ab..21635397ed 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_SINGLE_KEYATT:
+			_bt_specialize_single_keyatt(rel);
+			break;
 		case NBTS_CTX_DEFAULT:
 			break;
 	}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index ce6999d4b5..89d1c7ab01 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1122,6 +1122,7 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
 typedef enum NBTS_CTX {
+	NBTS_CTX_SINGLE_KEYATT, 
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
@@ -1131,9 +1132,43 @@ static inline NBTS_CTX _nbt_spec_context(Relation irel)
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
+	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+		return NBTS_CTX_SINGLE_KEYATT;
+
 	return NBTS_CTX_CACHED;
 }
 
+static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
+									bool *isNull)
+{
+	Datum	result;
+	if (IndexTupleHasNulls(tuple))
+	{
+		if (att_isnull(0, (bits8 *)(tuple) + sizeof(IndexTupleData)))
+		{
+			*isNull = true;
+			result = (Datum) 0;
+		}
+		else
+		{
+			*isNull = false;
+			result = fetchatt(TupleDescAttr(tupleDesc, 0),
+							  ((char *) tuple)
+							  + MAXALIGN(sizeof(IndexTupleData)
+							  + sizeof(IndexAttributeBitMapData)));
+		}
+	}
+	else
+	{
+		*isNull = false;
+		result = fetchatt(TupleDescAttr(tupleDesc, 0),
+						  ((char *) tuple)
+						  + MAXALIGN(sizeof(IndexTupleData)));
+	}
+
+	return result;
+}
+
 
 #define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
 #include "nbtree_spec.h"
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index fa38b09c6e..8e476c300d 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -44,6 +44,7 @@
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_KEYATT single_keyatt
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -51,8 +52,10 @@
 /* contextual specializations */
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
-	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
+		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		) \
 	) \
 )
 
@@ -164,6 +167,55 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 3: SINGLE_KEYATT
+ *
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path cannot be used for indexes with multiple key
++ *  columns, because it never considers the next column.
+ */
+
+/* the default context (and later contexts) do need to specialize, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel)
+
+#define NBTS_SPECIALIZING_SINGLE_KEYATT
+#define NBTS_TYPE NBTS_TYPE_SINGLE_KEYATT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	_bt_getfirstatt(itup, tupDesc, &NBTS_MAKE_NAME(itup, isNull)) \
+)
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_KEYATT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All next uses of nbts_prep_ctx are in non-templated code, so here we make
  * sure we actually create the context.
-- 
2.40.1

From 4c7d6b471c4025bedd7c386914c0913f409a57a5 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:57:21 +0100
Subject: [PATCH v13 3/6] Use specialized attribute iterators in the
 specialized source files

This is committed separately to make clear what substantial changes were
made to the pre-existing code.

Even though not all nbt*_spec functions have been updated; these functions
can now directly call (and inline, and optimize for) the specialized functions
they call, instead of having to determine the right specialization based on
the (potentially locally unavailable) index relation, making the specialization
of those functions still worth specializing/duplicating.
---
 src/backend/access/nbtree/nbtsearch_spec.c    | 18 +++---
 src/backend/access/nbtree/nbtsort_spec.c      | 24 +++----
 src/backend/access/nbtree/nbtutils_spec.c     | 62 ++++++++++++-------
 .../utils/sort/tuplesortvariants_spec.c       | 53 +++++++++-------
 4 files changed, 92 insertions(+), 65 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index 383010dc31..a93841e686 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -658,6 +658,7 @@ _bt_compare(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -690,23 +691,26 @@ _bt_compare(Relation rel,
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 
 	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, *comparecol, itupdesc);
+
+	nbts_foreachattr(*comparecol, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
@@ -735,7 +739,7 @@ _bt_compare(Relation rel,
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
 		{
-			*comparecol = i;
+			*comparecol = nbts_attiter_attnum;
 			return result;
 		}
 
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index 368d6f244c..6f33cc4cc2 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -34,8 +34,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -57,7 +56,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -90,21 +89,24 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 			else if (itup != NULL)
 			{
 				int32		compare = 0;
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index 0288da22d6..07ca18f404 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -64,7 +64,7 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -95,7 +95,10 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -106,27 +109,30 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -675,6 +681,8 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -686,20 +694,22 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -707,6 +717,7 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -747,24 +758,27 @@ _bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 705da09329..cf262eee2d 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -66,47 +66,54 @@ comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
 	bool		equal_hasnull = false;
 	int			nkey;
 	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
 
 	tuple1 = (IndexTuple) a->tuple;
 	tuple2 = (IndexTuple) b->tuple;
 	keysz = base->nKeys;
 	tupDes = RelationGetDescr(arg->index.indexRel);
 
-	if (sortKey->abbrev_converter)
+	if (!sortKey->abbrev_converter)
 	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
+		nkey = 2;
+		sortKey++;
+	}
+	else
+	{
+		nkey = 1;
 	}
 
 	/* they are equal, so we only need to examine one null flag */
 	if (a->isnull1)
 		equal_hasnull = true;
 
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
 	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+		Datum	datum1,
+				datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		else
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
 
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
 		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
+			return compare;
 
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
+		if (nbts_attiter_curattisnull(tuple1))
 			equal_hasnull = true;
+
+		sortKey++;
 	}
 
 	/*
-- 
2.40.1

From 1ee2045425d5a4f9c1a9473ba4a526d1fcbbec7f Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:13:04 +0100
Subject: [PATCH v13 2/6] Specialize nbtree functions on btree key shape.

nbtree keys are not all made the same, so a significant amount of time is
spent on code that exists only to deal with other key's shape. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, and splits the code that can
benefit from attribute offset optimizations into separate files. This does
NOT yet update the code itself - it just makes the code compile cleanly.
The performance should be comparable if not the same.
---
 contrib/amcheck/verify_nbtree.c               |    6 +
 src/backend/access/nbtree/README              |   28 +
 src/backend/access/nbtree/nbtdedup.c          |  300 +----
 src/backend/access/nbtree/nbtdedup_spec.c     |  317 +++++
 src/backend/access/nbtree/nbtinsert.c         |  579 +--------
 src/backend/access/nbtree/nbtinsert_spec.c    |  584 +++++++++
 src/backend/access/nbtree/nbtpage.c           |    1 +
 src/backend/access/nbtree/nbtree.c            |   37 +-
 src/backend/access/nbtree/nbtree_spec.c       |   69 +
 src/backend/access/nbtree/nbtsearch.c         | 1101 +---------------
 src/backend/access/nbtree/nbtsearch_spec.c    | 1113 +++++++++++++++++
 src/backend/access/nbtree/nbtsort.c           |  264 +---
 src/backend/access/nbtree/nbtsort_spec.c      |  280 +++++
 src/backend/access/nbtree/nbtsplitloc.c       |    3 +
 src/backend/access/nbtree/nbtutils.c          |  754 +----------
 src/backend/access/nbtree/nbtutils_spec.c     |  775 ++++++++++++
 src/backend/utils/sort/tuplesortvariants.c    |  156 +--
 .../utils/sort/tuplesortvariants_spec.c       |  175 +++
 src/include/access/nbtree.h                   |   44 +-
 src/include/access/nbtree_spec.h              |  183 +++
 src/include/access/nbtree_specfuncs.h         |   65 +
 src/tools/pginclude/cpluspluscheck            |    2 +
 src/tools/pginclude/headerscheck              |    2 +
 23 files changed, 3659 insertions(+), 3179 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.c
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.c
 create mode 100644 src/backend/access/nbtree/nbtree_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.c
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.c
 create mode 100644 src/backend/utils/sort/tuplesortvariants_spec.c
 create mode 100644 src/include/access/nbtree_spec.h
 create mode 100644 src/include/access/nbtree_specfuncs.h

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index e5cab3e3a9..c8b8b0d339 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -2680,6 +2680,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 	BTStack		stack;
 	Buffer		lbuf;
 	bool		exists;
+	nbts_prep_ctx(NULL);
 
 	key = _bt_mkscankey(state->rel, itup);
 	Assert(key->heapkeyspace && key->scantid != NULL);
@@ -2780,6 +2781,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2843,6 +2845,7 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2867,6 +2870,7 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -2906,6 +2910,7 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -3141,6 +3146,7 @@ static inline BTScanInsert
 bt_mkscankey_pivotsearch(Relation rel, IndexTuple itup)
 {
 	BTScanInsert skey;
+	nbts_prep_ctx(NULL);
 
 	skey = _bt_mkscankey(rel, itup);
 	skey->pivotsearch = true;
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 0f10141a2f..e9d0cf6ac1 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1084,6 +1084,34 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+Notes about nbtree specialization
+---------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes
+with variable length attributes, due to our inability to cache the offset
+of each attribute into an on-disk tuple. To combat this, we'd have to either
+fully deserialize the tuple, or maintain our offset into the tuple as we
+iterate over the tuple's fields.
+
+Keeping track of this offset also has a non-negligible overhead too, so we'd
+prefer to not have to keep track of these offsets when we can use the cache.
+By specializing performance-sensitive search functions for these specific
+index tuple shapes and calling those selectively, we can keep the performance
+of cacheable attribute offsets where that is applicable, while improving
+performance where we currently would see O(n_atts^2) time iterating on
+variable-length attributes.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also the default path, and is comparatively slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index d4db0b28f2..4589ade267 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,260 +22,14 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
-			   bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple and add it to our temp page (newpage).
-			 * Else add pending interval's base tuple to the temp page as-is.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place, when this page's newly allocated right sibling page
-				 * gets its first deduplication pass).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -316,6 +70,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 	TM_IndexDeleteOp delstate;
 	bool		neverdedup;
 	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	nbts_prep_ctx(rel);
 
 	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
 	newitemsz += sizeof(ItemIdData);
@@ -752,55 +507,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
new file mode 100644
index 0000000000..4b280de980
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -0,0 +1,317 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtdedup_spec.c
+ *	  Index shape-specialized functions for nbtdedup.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtdedup_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_do_singleval NBTS_FUNCTION(_bt_do_singleval)
+
+static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
+							 OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
+			   bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				minoff,
+				maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+				 _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple and add it to our temp page (newpage).
+			 * Else add pending interval's base tuple to the temp page as-is.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place, when this page's newly allocated right sibling page
+				 * gets its first deduplication pass).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+_bt_do_singleval(Relation rel, Page page, BTDedupState state,
+				 OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 8f602ab2d6..4a9ed5e7b7 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,28 +30,16 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, Relation heaprel,
-								 BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
 static void _bt_stepright(Relation rel, Relation heaprel,
 						  BTInsertState insertstate, BTStack stack);
-static void _bt_insertonpg(Relation rel, Relation heaprel, BTScanInsert itup_key,
-						   Buffer buf,
-						   Buffer cbuf,
-						   BTStack stack,
-						   IndexTuple itup,
-						   Size itemsz,
-						   OffsetNumber newitemoff,
-						   int postingoff,
+static void _bt_insertonpg(Relation rel, Relation heaprel,
+						   BTScanInsert itup_key, Buffer buf, Buffer cbuf,
+						   BTStack stack, IndexTuple itup, Size itemsz,
+						   OffsetNumber newitemoff, int postingoff,
 						   bool split_only_page);
 static Buffer _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key,
 						Buffer buf, Buffer cbuf, OffsetNumber newitemoff,
@@ -75,313 +63,8 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, heapRel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
-					   stack, itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-			AttrNumber	cmpcol = 1;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
-							&cmpcol) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
-
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
-					  BT_WRITE);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -425,6 +108,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	bool		inposting = false;
 	bool		prevalldead = true;
 	int			curposti = 0;
+	nbts_prep_ctx(rel);
 
 	/* Assume unique until we find a duplicate */
 	*is_unique = true;
@@ -776,253 +460,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	return InvalidTransactionId;
 }
 
-
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				AttrNumber	cmpcol = 1;
-
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
-					break;
-
-				_bt_stepright(rel, heapRel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			AttrNumber	cmpcol = 1;
-
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, heapRel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	{
-		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
-		Assert(P_RIGHTMOST(opaque) ||
-			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
-	}
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1506,6 +943,7 @@ _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
 	bool		newitemonleft,
 				isleaf,
 				isrightmost;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * origpage is the original page to be split.  leftpage is a temporary
@@ -2706,6 +2144,7 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 	BTScanInsert itup_key = insertstate->itup_key;
 	Page		page = BufferGetPage(buffer);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
+	nbts_prep_ctx(rel);
 
 	Assert(P_ISLEAF(opaque));
 	Assert(simpleonly || itup_key->heapkeyspace);
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
new file mode 100644
index 0000000000..969da194fd
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -0,0 +1,584 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtinsert_spec.c
+ *	  Index shape-specialized functions for nbtinsert.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtinsert_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_search_insert NBTS_FUNCTION(_bt_search_insert)
+#define _bt_findinsertloc NBTS_FUNCTION(_bt_findinsertloc)
+
+static BTStack _bt_search_insert(Relation rel, Relation heaprel,
+								 BTInsertState insertstate);
+static OffsetNumber _bt_findinsertloc(Relation rel,
+									  BTInsertState insertstate,
+									  bool checkingunique,
+									  bool indexUnchanged,
+									  BTStack stack,
+									  Relation heapRel);
+
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+_bt_doinsert(Relation rel, IndexTuple itup,
+			 IndexUniqueCheck checkUnique, bool indexUnchanged,
+			 Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = _bt_mkscankey(rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+	search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = _bt_search_insert(rel, heapRel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
+									   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
+					   stack, itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+			AttrNumber	cmpcol = 1;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&cmpcol) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
+					  BT_WRITE);
+}
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+_bt_findinsertloc(Relation rel,
+				  BTInsertState insertstate,
+				  bool checkingunique,
+				  bool indexUnchanged,
+				  BTStack stack,
+				  Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				AttrNumber	cmpcol = 1;
+
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0)
+					break;
+
+				_bt_stepright(rel, heapRel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			AttrNumber	cmpcol = 1;
+
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, heapRel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	{
+		AttrNumber	cmpcol PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpcol) <= 0);
+	}
+
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index b7660a459e..493f684e83 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1810,6 +1810,7 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 	bool		rightsib_empty;
 	Page		page;
 	BTPageOpaque opaque;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Save original leafbuf block number from caller.  Only deleted blocks
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 62bc9917f1..58f2fdba18 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,8 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -121,7 +123,7 @@ bthandler(PG_FUNCTION_ARGS)
 
 	amroutine->ambuild = btbuild;
 	amroutine->ambuildempty = btbuildempty;
-	amroutine->aminsert = btinsert;
+	amroutine->aminsert = btinsert_default;
 	amroutine->ambulkdelete = btbulkdelete;
 	amroutine->amvacuumcleanup = btvacuumcleanup;
 	amroutine->amcanreturn = btcanreturn;
@@ -155,6 +157,8 @@ btbuildempty(Relation index)
 	Buffer		metabuf;
 	Page		metapage;
 
+	nbt_opt_specialize(index);
+
 	/*
 	 * Initalize the metapage.
 	 *
@@ -180,33 +184,6 @@ btbuildempty(Relation index)
 	ReleaseBuffer(metabuf);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
@@ -348,6 +325,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -791,6 +770,8 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
 
+	nbt_opt_specialize(rel);
+
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
 		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
new file mode 100644
index 0000000000..6b766581ab
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -0,0 +1,69 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_spec.c
+ *	  Index shape-specialized functions for nbtree.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtree_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+_bt_specialize(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	NBTS_MAKE_CTX(rel);
+	/*
+	 * We can't directly address _bt_specialize here because it'd be macro-
+	 * expanded, nor can we utilize NBTS_SPECIALIZE_NAME here because it'd
+	 * try to call _bt_specialize, which would be an infinite recursive call.
+	 */
+	switch (__nbts_ctx) {
+		case NBTS_CTX_CACHED:
+			_bt_specialize_cached(rel);
+			break;
+		case NBTS_CTX_DEFAULT:
+			break;
+	}
+#else
+	rel->rd_indam->aminsert = btinsert;
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+btinsert(Relation rel, Datum *values, bool *isnull,
+		 ItemPointer ht_ctid, Relation heapRel,
+		 IndexUniqueCheck checkUnique,
+		 bool indexUnchanged,
+		 IndexInfo *indexInfo)
+{
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index 44a09ced98..d4604e7f99 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -26,12 +26,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
-								AttrNumber *highkeycmpcol);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -48,6 +44,8 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -72,591 +70,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- *
- * heaprel must be provided by callers that pass access = BT_WRITE, since we
- * might need to allocate a new root page for caller -- see _bt_allocbuf.
- */
-BTStack
-_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
-		   int access)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-	char		tupdatabuf[BLCKSZ / 3];
-	AttrNumber	highkeycmpcol = 1;
-
-	/* heaprel must be set whenever _bt_allocbuf is reachable */
-	Assert(access == BT_READ || access == BT_WRITE);
-	Assert(access == BT_READ || heaprel != NULL);
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, heaprel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access, &highkeycmpcol,
-							  (char *) tupdatabuf);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
-		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		highkeycmpcol = 1;
-
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
-							  &highkeycmpcol, (char *) tupdatabuf);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split is
- * completed.  'heaprel' and 'stack' are only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  Relation heaprel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  AttrNumber *comparecol,
-			  char *tupdatabuf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	Assert(!forupdate || heaprel != NULL);
-	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		AttrNumber	cmpcol = 1;
-
-		page = BufferGetPage(buf);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-		{
-			*comparecol = 1;
-			break;
-		}
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, heaprel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		/*
-		 * tupdatabuf is filled with the right seperator of the parent node.
-		 * This allows us to do a binary equality check between the parent
-		 * node's right seperator (which is < key) and this page's P_HIKEY.
-		 * If they equal, we can reuse the result of the parent node's
-		 * rightkey compare, which means we can potentially save a full key
-		 * compare (which includes indirect calls to attribute comparison
-		 * functions).
-		 * 
-		 * Without this, we'd on average use 3 full key compares per page before
-		 * we achieve full dynamic prefix bounds, but with this optimization
-		 * that is only 2.
-		 * 
-		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
-		 * we move right in the binary search on the page, this average equals
-		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
-		 */
-		if (!P_IGNORE(opaque) && *comparecol > 1)
-		{
-			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
-			IndexTuple buftuple = (IndexTuple) tupdatabuf;
-			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
-			{
-				char *dataptr = (char *) itup;
-
-				if (memcmp(dataptr + sizeof(IndexTupleData),
-						   tupdatabuf + sizeof(IndexTupleData),
-						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
-					break;
-			} else {
-				*comparecol = 1;
-			}
-		} else {
-			*comparecol = 1;
-		}
-
-		if (P_IGNORE(opaque) ||
-				_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
-		{
-			*comparecol = 1;
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-		{
-			*comparecol = cmpcol;
-			break;
-		}
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * When called, the "highkeycmpcol" pointer argument is expected to contain the
- * AttrNumber of the first attribute that is not shared between scan key and
- * this page's high key, i.e. the first attribute that we have to compare
- * against the scan key.  The value will be updated by _bt_binsrch to contain
- * this same first column we'll need to compare against the scan key, but now
- * for the index tuple at the returned offset.  Valid values range from 1
- * (no shared prefix) to the number of key attributes + 1 (all index key
- * attributes are equal to the scan key).  See also _bt_compare, and
- * backend/access/nbtree/README for more info.
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf,
-			AttrNumber *highkeycmpcol)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-	/*
-	 * Prefix bounds, for the high/low offset's compare columns.
-	 * "highkeycmpcol" is the value for this page's high key (if any) or 1
-	 * (no established shared prefix)
-	 */
-	AttrNumber	highcmpcol = *highkeycmpcol,
-				lowcmpcol = 1;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We maintain highcmpcol and lowcmpcol to keep track of prefixes that
-	 * tuples share with the scan key, potentially allowing us to skip a
-	 * prefix in the midpoint comparison.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol); /* update prefix bounds */
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-		}
-	}
-
-	/* update the bounds at the caller */
-	*highkeycmpcol = highcmpcol;
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-				   AttrNumber highcmpcol)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-	AttrNumber	lowcmpcol = 1;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &cmpcol);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowcmpcol = cmpcol;
-		}
-		else
-		{
-			high = mid;
-			highcmpcol = cmpcol;
-
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
-
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
  *
@@ -724,235 +137,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * NOTE: The "comparecol" argument must refer to the first attribute of the
- * index tuple of which the caller knows that it does not match the scan key:
- * this means 1 for "no known matching attributes", up to the number of key
- * attributes + 1 if the caller knows that all key attributes of the index
- * tuple match those of the scan key.  See backend/access/nbtree/README for
- * details.
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum,
-			AttrNumber *comparecol)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-
-	scankey = key->scankeys + ((*comparecol) - 1);
-	for (int i = *comparecol; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-		{
-			*comparecol = i;
-			return result;
-		}
-
-		scankey++;
-	}
-
-	/*
-	 * All tuple attributes are equal to the scan key, only later attributes
-	 * could potentially not equal the scan key.
-	 */
-	*comparecol = ntupatts + 1;
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -994,6 +178,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
 	AttrNumber	cmpcol = 1;
+	nbts_prep_ctx(rel);
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1627,280 +812,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan);
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2109,12 +1020,11 @@ static bool
 _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 {
 	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Relation	rel;
+	Relation	rel = scan->indexRelation;
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
-
-	rel = scan->indexRelation;
+	nbts_prep_ctx(rel);
 
 	if (ScanDirectionIsForward(dir))
 	{
@@ -2516,6 +1426,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	BTPageOpaque opaque;
 	OffsetNumber start;
 	BTScanPosItem *currItem;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Scan down to the leftmost or rightmost leaf page.  This is a simplified
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
new file mode 100644
index 0000000000..383010dc31
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -0,0 +1,1113 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsearch_spec.c
+ *	  Index shape-specialized functions for nbtsearch.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsearch_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_binsrch		NBTS_FUNCTION(_bt_binsrch)
+#define _bt_readpage	NBTS_FUNCTION(_bt_readpage)
+
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *highkeycmpcol);
+static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
+						 OffsetNumber offnum);
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ *
+ * heaprel must be provided by callers that pass access = BT_WRITE, since we
+ * might need to allocate a new root page for caller -- see _bt_allocbuf.
+ */
+BTStack
+_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
+		   int access)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+	char		tupdatabuf[BLCKSZ / 3];
+	AttrNumber	highkeycmpcol = 1;
+
+	/* heaprel must be set whenever _bt_allocbuf is reachable */
+	Assert(access == BT_READ || access == BT_WRITE);
+	Assert(access == BT_READ || heaprel != NULL);
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, heaprel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
+							  stack_in, page_access, &highkeycmpcol,
+							  (char *) tupdatabuf);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeycmpcol);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		Assert(IndexTupleSize(itup) < sizeof(tupdatabuf));
+		memcpy((char *) tupdatabuf, (char *) itup, IndexTupleSize(itup));
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		highkeycmpcol = 1;
+
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
+							  &highkeycmpcol, (char *) tupdatabuf);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split is
+ * completed.  'heaprel' and 'stack' are only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ */
+Buffer
+_bt_moveright(Relation rel,
+			  Relation heaprel,
+			  BTScanInsert key,
+			  Buffer buf,
+			  bool forupdate,
+			  BTStack stack,
+			  int access,
+			  AttrNumber *comparecol,
+			  char *tupdatabuf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	Assert(!forupdate || heaprel != NULL);
+	Assert(PointerIsValid(comparecol) && PointerIsValid(tupdatabuf));
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		AttrNumber	cmpcol = 1;
+
+		page = BufferGetPage(buf);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+		{
+			*comparecol = 1;
+			break;
+		}
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, heaprel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		/*
+		 * tupdatabuf is filled with the right seperator of the parent node.
+		 * This allows us to do a binary equality check between the parent
+		 * node's right seperator (which is < key) and this page's P_HIKEY.
+		 * If they equal, we can reuse the result of the parent node's
+		 * rightkey compare, which means we can potentially save a full key
+		 * compare (which includes indirect calls to attribute comparison
+		 * functions).
+		 * 
+		 * Without this, we'd on average use 3 full key compares per page before
+		 * we achieve full dynamic prefix bounds, but with this optimization
+		 * that is only 2.
+		 * 
+		 * 3 compares: 1 for the highkey (rightmost), and on average 2 before
+		 * we move right in the binary search on the page, this average equals
+		 * SUM (1/2 ^ x) for x from 0 to log(n items)), which tends to 2.
+		 */
+		if (!P_IGNORE(opaque) && *comparecol > 1)
+		{
+			IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, P_HIKEY));
+			IndexTuple buftuple = (IndexTuple) tupdatabuf;
+			if (IndexTupleSize(itup) == IndexTupleSize(buftuple))
+			{
+				char *dataptr = (char *) itup;
+
+				if (memcmp(dataptr + sizeof(IndexTupleData),
+						   tupdatabuf + sizeof(IndexTupleData),
+						   IndexTupleSize(itup) - sizeof(IndexTupleData)) == 0)
+					break;
+			} else {
+				*comparecol = 1;
+			}
+		} else {
+			*comparecol = 1;
+		}
+
+		if (P_IGNORE(opaque) ||
+			_bt_compare(rel, key, page, P_HIKEY, &cmpcol) >= cmpval)
+		{
+			*comparecol = 1;
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+		{
+			*comparecol = cmpcol;
+			break;
+		}
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * When called, the "highkeycmpcol" pointer argument is expected to contain the
+ * AttrNumber of the first attribute that is not shared between scan key and
+ * this page's high key, i.e. the first attribute that we have to compare
+ * against the scan key.  The value will be updated by _bt_binsrch to contain
+ * this same first column we'll need to compare against the scan key, but now
+ * for the index tuple at the returned offset.  Valid values range from 1
+ * (no shared prefix) to the number of key attributes + 1 (all index key
+ * attributes are equal to the scan key).  See also _bt_compare, and
+ * backend/access/nbtree/README for more info.
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+_bt_binsrch(Relation rel,
+			BTScanInsert key,
+			Buffer buf,
+			AttrNumber *highkeycmpcol)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+	/*
+	 * Prefix bounds, for the high/low offset's compare columns.
+	 * "highkeycmpcol" is the value for this page's high key (if any) or 1
+	 * (no established shared prefix)
+	 */
+	AttrNumber	highcmpcol = *highkeycmpcol,
+				lowcmpcol = 1;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We maintain highcmpcol and lowcmpcol to keep track of prefixes that
+	 * tuples share with the scan key, potentially allowing us to skip a
+	 * prefix in the midpoint comparison.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber cmpcol = Min(highcmpcol, lowcmpcol); /* update prefix bounds */
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+		}
+	}
+
+	/* update the bounds at the caller */
+	*highkeycmpcol = highcmpcol;
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highcmpcol)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+	AttrNumber	lowcmpcol = 1;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	cmpcol = Min(highcmpcol, lowcmpcol);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &cmpcol);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowcmpcol = cmpcol;
+		}
+		else
+		{
+			high = mid;
+			highcmpcol = cmpcol;
+
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+							errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+											ItemPointerGetBlockNumber(key->scantid),
+											ItemPointerGetOffsetNumber(key->scantid),
+											low, stricthigh,
+											BufferGetBlockNumber(insertstate->buf),
+											RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * NOTE: The "comparecol" argument must refer to the first attribute of the
+ * index tuple of which the caller knows that it does not match the scan key:
+ * this means 1 for "no known matching attributes", up to the number of key
+ * attributes + 1 if the caller knows that all key attributes of the index
+ * tuple match those of the scan key.  See backend/access/nbtree/README for
+ * details.
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+_bt_compare(Relation rel,
+			BTScanInsert key,
+			Page page,
+			OffsetNumber offnum,
+			AttrNumber *comparecol)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+
+	scankey = key->scankeys + ((*comparecol) - 1);
+	for (int i = *comparecol; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+		{
+			*comparecol = i;
+			return result;
+		}
+
+		scankey++;
+	}
+
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*comparecol = ntupatts + 1;
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			if (_bt_checkkeys(scan, itup, indnatts, dir, &continuescan))
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan);
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index c2665fce41..8742716383 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,8 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -544,6 +544,7 @@ static void
 _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 {
 	BTWriteState wstate;
+	nbts_prep_ctx(btspool->index);
 
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
@@ -846,6 +847,7 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 	Size		pgspc;
 	Size		itupsz;
 	bool		isleaf;
+	nbts_prep_ctx(wstate->index);
 
 	/*
 	 * This is a handy place to check for cancel interrupts during the btree
@@ -1178,264 +1180,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			Assert(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
new file mode 100644
index 0000000000..368d6f244c
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -0,0 +1,280 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsort_spec.c
+ *	  Index shape-specialized functions for nbtsort.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsort_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_load NBTS_FUNCTION(_bt_load)
+
+static void _bt_load(BTWriteState *wstate,
+					 BTSpool *btspool, BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			Assert(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
+										 itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index 43b67893d9..db2da1e303 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -639,6 +639,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	ItemId		itemid;
 	IndexTuple	tup;
 	int			keepnatts;
+	nbts_prep_ctx(state->rel);
 
 	Assert(state->is_leaf && !state->is_rightmost);
 
@@ -945,6 +946,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 			   *rightinterval;
 	int			perfectpenalty;
 	int			indnkeyatts = IndexRelationGetNumberOfKeyAttributes(state->rel);
+	nbts_prep_ctx(state->rel);
 
 	/* Assume that alternative strategy won't be used for now */
 	*strategy = SPLIT_DEFAULT;
@@ -1137,6 +1139,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 {
 	IndexTuple	lastleft;
 	IndexTuple	firstright;
+	nbts_prep_ctx(state->rel);
 
 	if (!state->is_leaf)
 	{
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 7da499c4dd..37d644e9f3 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,10 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.c"
+#include "access/nbtree_spec.h"
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1340,356 +1220,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-								 datum, key->sk_argument);
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if ((key->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((key->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2173,286 +1703,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
new file mode 100644
index 0000000000..0288da22d6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -0,0 +1,775 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtutils_spec.c
+ *	  Index shape-specialized functions for nbtutils.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtutils_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_check_rowcompare	NBTS_FUNCTION(_bt_check_rowcompare)
+#define _bt_keep_natts			NBTS_FUNCTION(_bt_keep_natts)
+
+static bool _bt_check_rowcompare(ScanKey skey,
+								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+								 ScanDirection dir, bool *continuescan);
+static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
+							 IndexTuple firstright, BTScanInsert itup_key);
+
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+_bt_mkscankey(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ */
+bool
+_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+			  ScanDirection dir, bool *continuescan)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
+									 continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+								 datum, key->sk_argument);
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if ((key->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((key->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
+					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+		/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			 BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			   BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index 84442a93c5..d93839620d 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -61,10 +61,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int tuplen);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
-static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
-											Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static int	comparetup_index_hash_tiebreak(const SortTuple *a, const SortTuple *b,
@@ -140,6 +136,9 @@ typedef struct
 	int			datumTypeLen;
 } TuplesortDatumArg;
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesortvariants_spec.c"
+#include "access/nbtree_spec.h"
+
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
 					 int nkeys, AttrNumber *attNums,
@@ -228,6 +227,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 	MemoryContext oldcontext;
 	TuplesortClusterArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	Assert(indexRel->rd_rel->relam == BTREE_AM_OID);
 
@@ -340,6 +340,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	TuplesortIndexBTreeArg *arg;
 	MemoryContext oldcontext;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -475,6 +476,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 	MemoryContext oldcontext;
 	TuplesortIndexBTreeArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -1299,152 +1301,6 @@ removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
 	}
 }
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	SortSupport sortKey = base->sortKeys;
-	int32		compare;
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	return comparetup_index_btree_tiebreak(a, b, state);
-}
-
-static int
-comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
-								Tuplesortstate *state)
-{
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
-	SortSupport sortKey = base->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = base->nKeys;
-	tupDes = RelationGetDescr(arg->index.indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(arg->index.indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(arg->index.heapRel,
-									RelationGetRelationName(arg->index.indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
new file mode 100644
index 0000000000..705da09329
--- /dev/null
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -0,0 +1,175 @@
+/*-------------------------------------------------------------------------
+ *
+ * tuplesortvariants_spec.c
+ *	  Index shape-specialized functions for tuplesortvariants.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/tuplesortvariants_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define comparetup_index_btree NBTS_FUNCTION(comparetup_index_btree)
+#define comparetup_index_btree_tiebreak NBTS_FUNCTION(comparetup_index_btree_tiebreak)
+
+static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+								   Tuplesortstate *state);
+static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
+											Tuplesortstate *state);
+
+static int
+comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+					   Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	SortSupport sortKey = base->sortKeys;
+	int32		compare;
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	return comparetup_index_btree_tiebreak(a, b, state);
+}
+
+static int
+comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
+								Tuplesortstate *state)
+{	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
+	SortSupport sortKey = base->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	Datum		datum1,
+				datum2;
+	bool		isnull1,
+				isnull2;
+
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = base->nKeys;
+	tupDes = RelationGetDescr(arg->index.indexRel);
+
+	if (sortKey->abbrev_converter)
+	{
+		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
+
+		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
+												datum2, isnull2,
+												sortKey);
+		if (compare != 0)
+			return compare;
+	}
+
+	/* they are equal, so we only need to examine one null flag */
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	sortKey++;
+	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	{
+		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+
+		compare = ApplySortComparator(datum1, isnull1,
+									  datum2, isnull2,
+									  sortKey);
+		if (compare != 0)
+			return compare;		/* done when we find unequal attributes */
+
+		/* they are equal, so we only need to examine one null flag */
+		if (isnull1)
+			equal_hasnull = true;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(arg->index.indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(arg->index.heapRel,
+									   RelationGetRelationName(arg->index.indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 0579120693..ce6999d4b5 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1121,15 +1121,27 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+typedef enum NBTS_CTX {
+	NBTS_CTX_CACHED, 
+	NBTS_CTX_DEFAULT, /* fallback */
+} NBTS_CTX;
+
+static inline NBTS_CTX _nbt_spec_context(Relation irel)
+{
+	if (!PointerIsValid(irel))
+		return NBTS_CTX_DEFAULT;
+
+	return NBTS_CTX_CACHED;
+}
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
+#include "nbtree_spec.h"
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1160,8 +1172,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
-						   Size newitemsz, bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1177,9 +1187,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Relation heaprel, Buffer lbuf,
 							 BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, Relation heaprel, BTStack stack,
@@ -1230,16 +1237,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
-						  Buffer *bufP, int access);
-extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
-							Buffer buf, bool forupdate, BTStack stack,
-							int access, AttrNumber *comparecol,
-							char *tupdatabuf);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-									   AttrNumber highcmpcol);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
-						 OffsetNumber offnum, AttrNumber *comparecol);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost);
@@ -1247,7 +1244,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost);
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1255,8 +1251,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1269,10 +1263,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
new file mode 100644
index 0000000000..fa38b09c6e
--- /dev/null
+++ b/src/include/access/nbtree_spec.h
@@ -0,0 +1,183 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ * - nbts_context(irel)
+ *   Constructs a context that is used to call specialized functions.
+ *   Note that this is unneeded in paths that are inaccessible to unspecialized
+ *   code paths (i.e. code included through nbtree_spec.h), because that
+ *   always calls the optimized functions directly.
+ */
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+#define NBTS_CTX_NAME __nbts_ctx
+
+/* contextual specializations */
+#define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
+#define NBTS_SPECIALIZE_NAME(name) ( \
+	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	) \
+)
+
+/* how do we make names? */
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define nbt_opt_specialize(rel) \
+do { \
+	Assert(PointerIsValid(rel)); \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
+	{ \
+		nbts_prep_ctx(rel); \
+		_bt_specialize(rel); \
+	} \
+} while (false)
+
+/*
+ * Protections against multiple inclusions - the definition of this macro is
+ * different for files included with the templating mechanism vs the users
+ * of this template, so redefine these macros at top and bottom.
+ */
+#ifdef NBTS_FUNCTION
+#undef NBTS_FUNCTION
+#endif
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+/* While specializing, the context is the local context */
+#ifdef nbts_prep_ctx
+#undef nbts_prep_ctx
+#endif
+#define nbts_prep_ctx(rel)
+
+/*
+ * Specialization 1: CACHED
+ *
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) do {} while (false)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_SPECIALIZING_CACHED
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * Specialization 2: DEFAULT
+ *
+ * "Default", externally accessible, not so optimized functions
+ */
+
+/* Only the default context may need to specialize in some cases, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * All next uses of nbts_prep_ctx are in non-templated code, so here we make
+ * sure we actually create the context.
+ */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+/*
+ * from here on all NBTS_FUNCTIONs are from specialized function names that
+ * are being called. Change the result of those macros from a direct call
+ * call to a conditional call to the right place, depending on the correct
+ * context.
+ */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) NBTS_SPECIALIZE_NAME(name)
+
+#undef NBT_SPECIALIZE_FILE
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
new file mode 100644
index 0000000000..cf27d406ae
--- /dev/null
+++ b/src/include/access/nbtree_specfuncs.h
@@ -0,0 +1,65 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+#define _bt_specialize		NBTS_FUNCTION(_bt_specialize)
+#define btinsert			NBTS_FUNCTION(btinsert)
+#define _bt_dedup_pass		NBTS_FUNCTION(_bt_dedup_pass)
+#define _bt_doinsert		NBTS_FUNCTION(_bt_doinsert)
+#define _bt_search			NBTS_FUNCTION(_bt_search)
+#define _bt_moveright		NBTS_FUNCTION(_bt_moveright)
+#define _bt_binsrch_insert	NBTS_FUNCTION(_bt_binsrch_insert)
+#define _bt_compare			NBTS_FUNCTION(_bt_compare)
+#define _bt_mkscankey		NBTS_FUNCTION(_bt_mkscankey)
+#define _bt_checkkeys		NBTS_FUNCTION(_bt_checkkeys)
+#define _bt_truncate		NBTS_FUNCTION(_bt_truncate)
+#define _bt_keep_natts_fast	NBTS_FUNCTION(_bt_keep_natts_fast)
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void _bt_specialize(Relation rel);
+
+extern bool btinsert(Relation rel, Datum *values, bool *isnull,
+					 ItemPointer ht_ctid, Relation heapRel,
+					 IndexUniqueCheck checkUnique, bool indexUnchanged,
+					 struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
+						   Size newitemsz, bool bottomupdedup);
+
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool _bt_doinsert(Relation rel, IndexTuple itup,
+						 IndexUniqueCheck checkUnique, bool indexUnchanged,
+						 Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
+						  Buffer *bufP, int access);
+extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
+							Buffer buf, bool forupdate, BTStack stack,
+							int access, AttrNumber *comparecol,
+							char *tupdatabuf);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highcmpcol);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *comparecol);
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
+extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+						  ScanDirection dir, bool *continuescan);
+extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright, BTScanInsert itup_key);
+extern int _bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright);
diff --git a/src/tools/pginclude/cpluspluscheck b/src/tools/pginclude/cpluspluscheck
index 4e09c4686b..e504a2f114 100755
--- a/src/tools/pginclude/cpluspluscheck
+++ b/src/tools/pginclude/cpluspluscheck
@@ -116,6 +116,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
diff --git a/src/tools/pginclude/headerscheck b/src/tools/pginclude/headerscheck
index 8dee1b5670..101888c806 100755
--- a/src/tools/pginclude/headerscheck
+++ b/src/tools/pginclude/headerscheck
@@ -111,6 +111,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
-- 
2.40.1

From 2970387e88cf40542ee507ff94bcc93d47961946 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 13 Jan 2023 15:42:41 +0100
Subject: [PATCH v13 6/6] btree specialization for variable-length
 multi-attribute keys

The default code path is relatively slow at O(n^2), so with multiple
attributes we accept the increased startup cost in favour of lower
costs for later attributes.

Note that this will only be used for indexes that use at least one
variable-length key attribute (except as last key attribute in specific
cases).
---
 src/backend/access/nbtree/README        |   6 +-
 src/backend/access/nbtree/nbtree_spec.c |   3 +
 src/include/access/itup_attiter.h       | 199 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  11 +-
 src/include/access/nbtree_spec.h        |  48 +++++-
 5 files changed, 258 insertions(+), 9 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index e90e24cb70..0c45288e61 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1105,14 +1105,12 @@ performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
  - indexes with only a single key attribute
+ - multi-column indexes that cannot pre-calculate the offsets of all key
+   attributes in the tuple data section
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
 
-Future work will optimize for multi-column indexes that don't benefit
-from the attcacheoff optimization by improving on the O(n^2) nature of
-index_getattr through storing attribute offsets.
-
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 21635397ed..699197dfa7 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_UNCACHED:
+			_bt_specialize_uncached(rel);
+			break;
 		case NBTS_CTX_SINGLE_KEYATT:
 			_bt_specialize_single_keyatt(rel);
 			break;
diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..c8fb6954bc
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,199 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup_attiter.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+#include "varatt.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 89d1c7ab01..5d2fb4b5db 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1123,18 +1124,26 @@ typedef struct BTOptions
 
 typedef enum NBTS_CTX {
 	NBTS_CTX_SINGLE_KEYATT, 
+	NBTS_CTX_UNCACHED,
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	AttrNumber	nKeyAtts;
+
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
-	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+	nKeyAtts = IndexRelationGetNumberOfKeyAttributes(irel);
+
+	if (nKeyAtts == 1)
 		return NBTS_CTX_SINGLE_KEYATT;
 
+	if (TupleDescAttr(irel->rd_att, nKeyAtts - 1)->attcacheoff < -1)
+		return NBTS_CTX_UNCACHED;
+
 	return NBTS_CTX_CACHED;
 }
 
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 8e476c300d..efed9824e7 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -45,6 +45,7 @@
  * Macros used in the nbtree specialization code.
  */
 #define NBTS_TYPE_SINGLE_KEYATT single_keyatt
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -53,8 +54,10 @@
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
 	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
-		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		(NBTS_CTX_NAME) == NBTS_CTX_UNCACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED)) : ( \
+			(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+				NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+			) \
 		) \
 	) \
 )
@@ -69,8 +72,11 @@ do { \
 	Assert(PointerIsValid(rel)); \
 	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
 	{ \
-		nbts_prep_ctx(rel); \
-		_bt_specialize(rel); \
+		PopulateTupleDescCacheOffsets((rel)->rd_att); \
+		{ \
+			nbts_prep_ctx(rel); \
+			_bt_specialize(rel); \
+		} \
 	} \
 } while (false)
 
@@ -216,6 +222,40 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All next uses of nbts_prep_ctx are in non-templated code, so here we make
  * sure we actually create the context.
-- 
2.40.1

�PNG


IHDR�����H IDATx^��M��]7�����f^��@x"�ZA��$�AB�GD����HH����b"�a5�WLV���8�LVnKH�<��)bF
�Z�A�xO�OH����{�����[��9u>-!���s~��;=t�{�j�Q�| @�
 @�
 @�
HP`C��`��L�
 @�
 @�
 0v� @�
 @�
 @�
�
��m��	 @�
 @�
 @�
�]�
 @�
 @�
 @�@���d[�p @�
 @�
 @�
a�=@�
 @�
 @�
 ����+��)�
 @�
 @�
 @@�e @�
 @�
 @�
$+ �J�u
'@�
 @�
 @�
v� @�
 @�
 @�
�
��m��	 @�
 @�
 @�
�]�
 @�
 @�
 @�@���d[�p @�
 @�
 @�
a�=@�
 @�
 @�
 ����+��)�
 @�
 @�
 ���������]y�
�&@�
 @�
 @�
tB@���6Z
 @�
 @�
 @ O
aW�}�j @�
 @�
 @�@'�]�h�E @�
 @�
 @�
�v��w�&@�
 @�
 @�
tB@���6Z
 @�
 @�
 @ O
aW�}�j @�
 @�
 @�@'�]�h�E @�
 @�
 @�
�v��w�&@�
 @�
 @�
tB@���6Z
 @�
 @�
 @ O
aW�}�j @�
 @�
 @�@'�]�h�E @�
 @�
��@����
�n>
��+XW+�����g��;���[��$@����]�Y��
 @�
 @ �I�qB=��8z��+�_�>t`�����
mv����p+\
7�{r���g��	���"�~���;w�?���N��{��������C�����Z��"�z&\��nx��_n\<FtR�E�u�8��w��W.����y�~���
6��k��$@����]��73
 @�
 @���&a����S������~��v;���{E����7�����f������j�z~�w�����kw��<��v��������7�������n���<3[d�5��^��d��/�����^q���QW�B���) �����=k3 @ q��c�>y8Vy�5l]������w�W_��S����_[/�6�����W8��OqN�Q���>mY�DG @�
 �*��a����]P���=�������I=�//������>��^x��G��	��=�a��z%<���������iq�X�����e�t��p��_o��t�p������1=2p���jO�
j�j�9�
�	��j}��`�o��_z+�N���x.\�p1l^x,��������a�� �*y�E�O&?����8���^|�����z�����Dx��3�6��������!����� @�
�Q�r�q;���'��9t�U���?'����������_|;���o�{�\84H��k4���WC���_x}"�����\�,��JC�Iv�R�����B�[����5�w7�~%\��rx��w�k����O|,<�}#�Z�>7���{�u/l�o�=>�L�x�F�q��p���]����\
/n������0_�7^y�����'>[��7B�!p���/���{��y1�P��
�
�����	 ����>yx������?���o���G�����L�)���������!�\�U<��Oq�/>��Q|R�x�|x���'��n� @�
��@�k���r��c�v�^W���>>��a�UX��]���v������^�yBGe��7�$�=��W<�q�n�j����������e7<}�j�z��p������;��
>���6�����T8��vxy�x���7����^�xt�o�{�xl��������b��^|��p����W_	����;�|�Y�g�k��;���t����������nx�K���7�"@����VoltD`E�<��D�~)���+�����{^�~1��dq������}-s!V��c>�y������s� @�
�F��5A��/��Vx6|���I����H���������{h���x
Y�(>TX$2�bUMN�$���3���w���O��w6P���N
���*��x��S��&���A��YJ����8H,������r>|�o
M�]\�N�T�zf��{P0>>s���@rrw����Q������ ����+���
�	T�[���g�0|c���E����X�s����:�]�t�� @�
�/0���a�w�F�z�����-CO|�k����U����#O��r}�9�e�wj��)�z�f<�bt�Ra������bxg�=ZK�i�������L�5x��'�O�V����g�6�����g�oxx�����������/��3��?,z�������?1=�����'GN�S�cN=�p���g.�[����������]�h��w
�v�bs
r�x1��'������>&���p�����'�>��������T���>�yxhaW�?�L�
 ��@�`�x��v�����
l��x
����]R_���'LB��G
6v
����_���]�����5|o��]��*{���sR�5����PG���1�:����]o�����^�H���������)����N���{&\�S<�7�� @����]�Y�
�~1��'�j���^�Z��w���p�t8s�Bx��s��+W��^I�U������')��]s>�y�������#@�
���Ia�����{��\��p��V(�i�1����'���+���\>����i�Zi�uR�]��
��N���	[��	w���p���6��^v�=v�������������8���S<���#���� PO`o��Cw�%��g�,d(P=�Z���G$�����_�
���zx��7�����8�l����/L=5}�ORV�������]�LX2
 @�@�';����}8|�/J�",|�`h����r��U��K�����:��2*��G�X�FT��A�~��0x��'��[��6��|�1��<�������^|�x7��d6����#�q���c�s_�
O����S�������g��w�g������� @�=
aW{�f"@�@�^���o�'+�<�_�>���g�g�.:�'-s!���8�-���I� @�
�H`��DIp3S���O\���W��&
��p�+���W�
�o���3x�8����4�Z�����LQ��E��/�����������j�����]e��_\X��(�w�������O�?�����{ub��?�r��"�<v�uXq8� @�@=
aW=7g @ C��/�*}��������B���k��e?�y�naW�N:�
 @�@$�'�C����U8���.~}5�x���!��
�>���
�����p���/�S�K���{E@U�����xUl�����w�mz�_=�����K�<f����^��X�__~����I=��Sk�W`.�3��F�t!�<L���a�w5��x=���BxfX�����������K����uj��{�xt�g���8����#@��
��
H!@���@���y�<|3l�.���c����N��������z����y��<�)�]~L @�
�%0��`�����7��n8u�+���!�"�U�uq+�zur�S��jT����O���;J�	�N�
��<?8����n�O���?��z������j�i?<����@�l'�?J~*:a�4v�O�x<��W���E���n�~����3�O��Fx{&������Ko�N��p��f8_X�o_������M�u�;����}� 4��f�GN���1Q-
Rv��)u @`�5/��|�����������g>�������`��1�S_����y�����t�=�S��v�}�*�
 @��B�	�ak�h�C�����qU����a�������Fy�1aW)��p���p��������7s����:k��]�������t��I4}7�q�6v
�'_
W^x1���N�|O|,<���p��{���g��#w�����b�z�������	�N�3�7���W�c����+
�&==rr:[h�:�
*�*S9�
���
�?yX<������\A�'>v!<�;�t���k��[����������������a'+^��)���A����� @�
 @�
�I@��&x� @ =��a�����~�p��x,����u=��f?�3|���������{!\}e+\=�#6�b�zb��S���vU��� @�
 @�
4* �j��` @�
 @�
 @�
m
���6
 @�
 @�
 @�@���F9
F�
 @�
 @�
 �����Mms @�
 @�
 @�
4* �j��` @�
 @�
 @�
m
���6
 @�
 @�
 @�@���F9
F�
 @�
 @�
 �����Mms @�
 @�
 @�
4* �j��` @�
 @�
 @�
m
���6
 @�
 @�
 @�@���F9
F�
 @�
 @�
 �����Mms @�
 @�
 @�
4* �j��` @�
 @�
 @�
m
���6
 @�
 @�
 @���{{{�c���4
 @�
 @�
 @����]��7/
 @�
 @�
 @������	
@�
 @�
 @�
 �.
a����K�
 @�
 @�
 ����kiB @�
 @�
 @�
�K@��.y� @�
 @�
 @�
,- �Z�� @�
 @�
 @�
�v�K�� @�
 @�
 @�
K��&4
 @�
 @�
 @����]��7/
 @�
 @�
 @������	
@�
 @�
 @�
 �.
a����K�
 @�
 @�
 ����kiB @�
 @�
 @�
�K@��.y� @�
 @�
 @�
,- �Z�� @�
 @�
 @�
�v�K�� @�
 @�
 @�
K��&4
 @�
 @�
 @����]��7/
 @�
 @�
 @������	
@�
 @�
 @�
 �.
a����K�
 @�
�v77��[e�_
7�����v7����g��;����>��1eSU9o�1��^8�sw<����;\k����zN$@�
R��N
]Rc,�
�f/��
����EO,�Y @�
d"0��7��"L:�k4]��(����������*��p�������;Wsw�a�H�J�t��L�k� @�@!������{{{�t2�Ye����5�
=~� @�
 ���8���vs�0<�	�aV����U9��1��g��]�w�
���?�����;�?H�| @�
	�}'�f[j���.�����*43�.LJ?@X��
���i`{�
 @��n
T����k�i��N����?�f�rc*�:�������/l�v
�XR`G����Z
 P�����i�w���{�^�u\SfM�����t�G� @�
HO`tM�����[a�������
��� G�<���,�����=&����o�C�/Lo[��
4*���F9
�y�<����/Mq��(\�t��	 @�
�Q`tw���S�������������{�����I�������H����I\7y������c�|j"@�
-	�}�%h�tD��a���G.�k�?��p���.z:��a @�
�'0����#�Y�]�o��yw��N��<��=e�w��?��H�=z>�����G��S� @�C�{������g��	�^��s���N�����@��a���(�
%���>j��P�8�j��g������'?�I������l-C ����@��������u�k`����	~?����3HB`�G��1�eO83�|��}o���u������?|���=��A��O��O�#�HT$
���{����_���@�C�Px���*.=��w*9,S�l������eX���C���6x�3X�_��_������?g��o�:.��mo���T������O>���-�@��k����vBo�=�!�"��{�*��\2���F����y�w'�����<�������������� @�����������
��c����M�M\ ��k�?�A�����"������y�������w~�w���'@�
t[����fx�����'�8F��5��Gz�P(B�sa�w���c���N?l���N�9�l�*�U9������n�*�K�e� @���
���������t/�^�
�N��^YH5���0J��gP��k%?W%@�
4. �j���)�����<�c�n�Ka�������1����p��9����'}���Ucx\;����FW;
tE�V�����#�}�*���krw����Bc�(�[gG��
�P����/z�]ULG�
X���k�=PAl�p��tYg��;���<��+{���c�}tcO�:����eMB������V��!�b���!@��j�]C(����_���@���(��F�
���E�=wv���q
 @�m
aW���#�

aW7�h ��@��+�u��@��
��DLy.aW��S;
 ����+�n[+���]�Y�
�v��s�����V�<R����Z
 �A
aW�jIZv��l
 0G@�e�X���k��Q� ���=�#@�
��l����9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�nU@��*w|�	����� @�
e�.���:��:j�!@�
�
���4�2
aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��W.����?��k��qO ���?�#@�
L�]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�# ���� �����YO�(ve�/�(b
 IDAT]�o�'@�
�v%�*��J@�U;C�
�
�2m�e�* �j�;���]��DE @��2
a�}A�@
aW5� @��f�]�z�@���+�}!��|X>
 ����+�V)�@T������T@��i�-�U
aW���M&���'*"@�
�	������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�nU@��*w|�	����� @�
e�.���:��:j�!@�
�
���4�2
aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L@����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�# ���� �����YO�(ve�/�]�o�'@�
�v%�*��J@�U;C�
�
�2m�e�* �j�;���]��DE @��2
a�}A�@
aW5� @��f�]�z��D`oooC����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�# ���� �����YO�(ve�/�]�o�'@�
�v%�*��J@�U;C�
�
�2m�e�* �j�;���]��DE @��2
a�}A�@
aW5� @��f�]�z�@���+�}!��|X>
 ����+�V)�@T������T@��i�-�U
aW���M&���'*"@�
�	������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�nU@��*w|�	����� @�
e�.���:��:j�!@�
�
���4�2
aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L@����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�# ���� �����YO�(ve�/�]�o�'@�
�v%�*��J@�U;C�
�
�2m�e�\`oooa�����@�wTG�
�������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�nU@��*w|�	����� @�
e�.���:��:j�!@�
�
���4�2
aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L@����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�# ���� �����YO�(ve�/�]�o�'@�
�v%�*��J@�U;C�
�
�2m�e�* �j�;���]��DE @��2
a�}A�@
aW5� @��f�]�z�@���+�}!��|X>
 ����+�V)�@T������T@��i�-�U
aW���M&���'*"@�
�	������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�nU@��*w|�	����� @�
e�.���:��:j�!@�
�
���4������>��+�}!��|X>
 ����+�V)�@T������T@��i�-�U
aW���M&���'*"@�
�	������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�nU@��*w|�	����� @�
e�.���:��:j�!@�
�
���4�2
aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L@����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
�K���^
�'������paW^��j	4% �jJ�8 @�������3	TvU���q���6�� @��d~��:|����=���+��)�@:��tz�R���������x�]��b-����nR @������f @`���U��
TvUsr�e�]��u�\aW�h	 @�@������x���o�	 @ 
aWM�������� �Z���	 @�
�.{��U
�V�kl PM@�U��Q�v-���s�]h�% @�
I��n��	D/ ���E
$@���]4��. �Z{�[��k��f'@�
��
V) �Z���	 @�@5
aW5'GXF��aW�������n>�
��Z��a�����9{-��o�����u���g�PR1���F��/����vU�r
 @`E���������F @�
�v��*��������:v
�[������Q�n>*��G?l����0U9�l�T9o�1���;W�sw�a�H������������c�lWaW5� @�
�v5gi$�
��
 �~
a��{���t/�@;!\����h�5���0�[���h'T?�l�44vq�Fqw���f�pl���pnw��:�����N�
hX@��0���v� @`�����@��^�u\�������Q�5}Bq'����eWn�?f:L+
������a���E�G����v-�p @�@����A
G���� @�
�	�"k�r:)�G�5y����\�?����F�<���+���3����ij����?����N�,�����E @�
		�j�R	$(�����d�����s-��:v
�~��;f�z���@j����~8wR 6�n���68v����G����/vE���$ @ K
aW�m�h�	�Z�6
8V@�esX�@���i�Q�5x�Wq7W��]��]37�M3�����h�y��w�M
���W��xdG����������o��o�~���
-
lll�G��8�� PO���������=���~g�����p���z9��,�]Y���	 @ 2
aWd
QN'�	�����uk�(�*�(�r�*cX6�x
a�����v��7������������������?��
nQ�+��| ����O�VN�@2��������<�:u���\��G>"�J��
%���+�>��
�v���oG ��k�}\��a���84:�F�kwB���3����0��i�f����p9��5��V��u\��?W�B��UE�1 @���	x���l�L�@�.��
�_@������������.�dm��{�vz��7���k����T86}���1e��yU�94�p]������vu��
	 @������c+$�N
a�:��M�
F�.;����v��{�.	�.�:;zg��eXGB����13���d��y�����#
y��q[��]��!3
 @�$
a��A��*�]��56
�& ����(�t0�q�wk�f6�4�l�k�>����W�Sv�
Xz����_xP�$��������x�v-���\ @������
�@����.��
�_@�������
����fV(�j��( @������r�#@�������c @��j�]��5:����+�} ��|X>
 �v
a��[��vu��G�
��i�2�v%����v-oh @��2��e��K��<
a�<!�'@�
�v����]��
aW���	 @��������������8HD@��H������+��-_��kyC# @�
�v-��\�	��	�>
X���k��f  ��|�2��O�
�]@���(�@��]�n�� @�@"��D����]I�o���]��
 ����k=� 0O@�5O��	 @����]�76
aW�{@����| @`�����@
:- ��t{-�
v%�(e&- �J�}�/�Z�� @��e�]��9��y��yB�O�
V/ �Z���2����7�� @�
k8u�T��?���������|�#����gj��7���p�������v��+� @�@w�]�����W`ooo�a�z{����]ko� @���a����������?��?ve�7,�@��&�A�
�v-��lU�]U�:|������4 @ 	
�1L�M�$����+��)�
:$ ��P3-%Z
aW��i�0aW;�f!@�
' ��7X���k���&@�
��]��E`
a�2z8W���&Z
 ����+��)�@����[�@�@@��A�-q�����`����ov @���� @`���U��
TvUsr�e�]��u�\aW�h	 @�@������x���o�	 @ 
aWM�������� �Z���	 @�
�.{��U
�V�kl PM@�U��Q�v-���s�]h�% @�
I��n��	D/ ���E
$@���]4��. �Z{�[��k��f'@�
��
V) �Z���	 @�@5
aW5'GXF@���^�vu���@�
$- �J�}�'���+�)�
2ve�dK\���k�-Xo
������
  ��X���k���&@�
��]��E`
a�2z8W���&Z
 ����+��)�@����[�@�@@��A�-q�����`����ov @���� �����F�|+�K7����1�?l�1�:{-��o����U�)+��ys��o�������/���v�t��o��/������C @����
�����F>i
aW��[�xa���F @�
,# �ZF���S��L�5�������������*��t-5v+�����~�.���?`����tZw��E{.�ZT�� @�y�F�.��4�#vJ@���v.�a��f� @�
4) �jR�Xy
a����]�������kl�����qU�)S�r^�c�{�6�;���4�#����h���;�?H�j|	�j�9�
4,�|�����[b�
�:��E�$�ZD�� @����]��1/�����owIM�]�;������������������LM�}a���k���";���Z,�Z�� @`E��]~�YQc�)
aW����b�]��9�
 �����IMce'0|�O?\<0
���7sS��WE���q���l,��������.����^ve�Sa� ��Ra��w"���bv���kv��m* @�@����� PW`����W����H
�����&aYY�5�n��2�xNa8�sw<��p�Q��_(�����G�
��v�}��n�����v����]�F�
X���kE������q>�"��o�aN�h�U�&��ww��D�����l�������H;����(����k��k��H�
b�����|���+��+�%>��S��'�8�=����Qu�( ���+-�$�j�T @��
a�mA��@��U��]�"4Z�c���/���(�=�����M����ax�}���?�D�E�
�G`�����R������K��K��������3�]������R=N����Z
 ����+�V)4"����o�TP�8�;��un'������S�*����c�H<�u8X����c���~��;�?o������������'�� @`�uc�����V�!3�*����_��+�.6T���!H� @�
j
�j�9���j����\�UE(u��{U�)��r^�c�=�w��k�=a��N�
��v����n���Q����I�XA��&C��p��N�
tB@���6ZDew[
��[����]%��S����wB�6����p���;s���+Da���wv��9�@�
��.�*d���Q�����}Y�H@���Nve�
,�
X���k�-P@W�{���w��y���^�o�9��*�7�������G3����8��;Z��k�=�G���
n ���J����ot��������v5g��H��$��h @�C��5�RD( ���)J"@�������`��]��:y����m�( @ !
aWB�R*��]	6M� �9
aW�ZjA
�"lJ�%	���6
\�� IDAT @������ @`���U��
TvUsr�e�]��u�\aW�h	 @�@������x���o�	 @ 
aWM�������� �Z���	 @�
�.{��U
�V�kl PM@�U��Q�v-���s�]h�% @�
I��n��	D/ ���E
$@���]4��. �Z{�[��k��f'@�
��
V) �Z���	 @�@5
aW5'GXF@���^�vu���@�
$- �J�}�'���+�)�
2ve�dK\���k�-Xo
������
  ��X���k���&@�
��]��E`
a�2z8W���&Z
 ����+��)�@����[�@�@@��A�-q�����`����ov @��7���p������q"�7��������3g�@#@�@e
aWe* @���	�VFk`����7��+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�# ���� �����YO�(ve�/�]�o�'@�
�v%�*��J@�U;C�
�
�2m�e�* �j�;���]��DE @��2
a�}A�@
aW5� @��f�]�z�@���+�}!��|X>
 ����+�V)�@T������T@��i�-�U
aW���M&���'*"@�
�	������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo�+�����C��r��'v��� @�
&�.{��:��:j�!@�
�
���4�2
aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L@����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
x��A������{��{�'
��t4�:��:j:G���fZ

 �i
aW��kqV& �Z��	 @����?��?���>��?����� �&
a���c�V�K'�A�
8Y@�e� PG@�UG�9 @`1�A��[��[�������G.^�8��;��t4�:��:j:G���fZ

 �i
aW��kqV& �Z��	 @���� ��������/~q��~�W5��/����>!�����%�X�v��u @�
f�]v
u�]u��C�
����M`��U�&4��+�f)�
�Z@��u�-�@m
aWm:' @������T$�2
a��h�X��F�TI�
v��v�Qs
XL@�����	�B@��
���v%�,� @�
Y��n���- ��M�D PY@�U���V& �Zm����*	 @�
�.{��:��:j�!@�
�	��r4�U�V���������T @ k
aW���x��]���H�
*�*S9����]+�Mc`aW}R%
 @@�e PG@�UG�9 @`1
a�b^�&�

a�*TS��P��J�
d- ����O�����6�	 @�@e
aWe*X���ke�i,�J�O�$@�
��
����9�
,& �Z���V! �Z�jBc
�j�R	 @����]Y���	�v��s"
�, ��L�@+v��6���]i�I� @�
a�=@�@
aW5� @����]�y9�@S{{{�C	��RMtaW��S6
 ����+��[0�F�]�0�
�( ��A�_@�����a�Z�MN�
�, ��L�@��]�
X���k��f 0O@�5O���vu���G�
tF@���VZ�V�]�r��
2ve�x��J@�U;�/F����	 @�
u�]u��C���� @�
�v����	��	u�����7�� @����:�J!�����Un� @�@���Lo�Q	��jG����77#
 @�������sv� @`�������<
a�<��_���[
 �
aWgZi!Zv��m2�T@��i�-;*
aWT�h�aW��f$@�
�v�Qs
�.{�
�^@��zc3�' ��'����:�`�#@�
:# ��L+-�@���V�MF�
�
�2m�eG% ����#�j��� @��:��:j�!@@�e @����Vol��]��:�}aW�ly @�@g�]�i��hU@��*�� @ S
aW������]Q���b�]����
 PG@�UG�9��
 �z
a����@`���k�P��/��x�-�
�����3���
�Z�6
d* ��������+�v�_���}s3 @�
����9�
a�=@�
V/ �Z���v�����]o�� @�
�vu��B�U
aW��&#@��L�]�6���vE����v�onF @�@
aW5�  �� @����]�76�y��yB�����
�< @�3�����B�* �j��d ����+��[vT�����~1�����H�
�# �����]�
X���k��f 0O@�5O���vu���G�
tF@���VZ�V�]�r��
2ve�x��J@�U;�/F����	 @�
u�]u��C���� @�
�v����	t6��o�����S��n>�
�������o���v7����g��;����'[��9����P]���W���fa��F�>
 @ 
aW}P���]�uL� ����+����{{{���d�5
�B�v����T?l�������0�
7��"p:�kF]��h�y���KU��wL+����x
��:���v�Qs
 @�}
aW��f$�
aW�h
 ���+��/��]E@�q9���	�Q�5�C;�7���W�����cf�)�"U��pLq�F���E6���<�v7�s�]+�Z�� @��5	��oZ��o��	 @ 	
aWmRd�:v��E��cC�c����U��rc*x��wj�['�]������#O�������[
 �
aWgZi!Zv��m2�T@��i�-;*�|���c��G�����]
���p�f���b�?��9w�U9��j9f����?����NfvE��� @����.���:��:j�!@�
�	��r4�Udv����ui������N�{��{���V�����y��pn?x+	��c�\���I7	��A���/v����� @���	�Vgkd]vu���F�
��b��:r� �*��k���V���
6�����������5	��������[��V��������w���������9�X;��=z���oll���m]
��"@`}���?�s?��9��"�L�@r���Z�`HP��?�a����������|�;��_�z���?����L 
�n�]���V'�@�m�zDa�G
���v������Fa\��h�����v�~�p]������)�'?�I���~�g6��J�j�����o��7_�	��4�:�.��/�����sd, �����N�
���i�B:,���kt��v'��K��*i�T�5|g�N���������*w�>�9�a��cJ�������Q����6�'������[����� @���<�p�=P
��])vM� �5
aW�:j=1
t3�Na���h��y�������X�wp
�)�;�P��Mf��W��C�e�
n�*�K����� @�
�v�����. ��z���
Rv��%5�.���k$�k�N;���5���<�p���K�����K�ww
����	E�6~U8o�n�[�G�$,���pm���Q��c�����J�GX� @�@.��\:m��v5�i4 PG@�UG�9�^�5	��q8x��(@*��u�u�$ ���kr�����]�c��7��1��f_xP�$���b�l�#�Z��� @��u	��%o^i�����	 @���n��*��^��wt�	��k�� @�
��.��:��:j�!@�
�
���4�2
aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L@����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�# ���� �����YO�(ve�/�]�o�'@�
�v%�*��J@�U;C�
�
�2m�e�\`oooa�����@�wTG�
�������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�nU@��*w|�	����� @�
e�.���:��:j�!@�
�
���4�2
aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L@����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�# ���� �����YO�(ve�/�]�o�'@�
�v%�*��J@�U;C�
�
�2m�e�* �j�;���]��DE @��2
a�}A�@
aW5� @��f�]�z�@���+�}!��|X>
 ����+�V)�@T������T@��i�-�U
aW���M&���'*"@�
�	������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�nU@��*w|�	����� @�
e�.���:��:j�!@�
�
���4������>��+�}!��|X>
 ����+�V)�@T������T@��i�-�U
aW���M&���'*"@�
�	������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�nU@��*w|�	����� @�
e�.���:��:j�!@�
�
���4�2
aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L@����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�# ���� �����YO�(ve�/�]�o�'@�
�v%�*��J@�U;C�
�
�2m�e�* �j�;���]��DE @��2
a�}A�@
aW5� @��f�]�z�@���+�}!��|X>
 ����+�V)�@T������T@��i�-�U
aW���M&���'*"@�
�	������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�^���������s�=��+����
 0v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L@����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�o�����S��n>�
����n��������p��z�S����]CI������r���
�B�U
�! @`���]~�Yqs�
aWgZYo!��zn�"@�
�- �j[�|��[������Q�n>*����a�w.������1']K���
�sE8w����mX���}:f���s<
h^�n�����{a��
����J+vUbr
 @`�����@
1	����	�AJ4��}on���^Yx��S����.�A�(�N���l�M�y��nZ��v-��P �"�Za��wV�
�vU@����V\���"�� @�
kv��
�OC`�.��(�Z��wRm\�APv���c����Pm��/l�v
[T���tC���C	 @���j�]�����u����R������t:
 @�%
aWK��IW`���K�;���7�x�5uWVv�=f6)
����������/��W����V9
tG�����;��V�����q��v��/� @�
�
������,0����wx�������s'b����.�������s;w��O�r�<�P��'�
�#�l����xz��x�]������]�0��
 ����kiBd 0����������s���$����l���ww��D�����l|������o��G��������(|���T IDAT�C�`X"
�S`���<x>�����������h��s�}����ve�����]�o�'@�
�v%�*��U`�>�[�GVyDa�cV�����h
a�����v�~o��?��?�����#��\�{�n��'?�����
�,���?���[�ZO>�dx���*���NE �e* �����e�2��O�
$# �J�U
]���������	�qhtP�������~v�=f��_�a���Z�����r8�{k���^Q��������]��|�
�^`���V����w�)
�R�Z�5��4
 @`����:=����/�dm��{�vz��7���k�����?M�e5sLO���sh���7u���%�Jo{��
�v�}g��>v�*��*J>F����Z
 �)
aW��i1KL�cu�H0t����;�/�:��D%
T�cf��1y�V��*��oQ�����1<���]Ko6 @���j�]��;�O|^����������.aWE(� @�
�, �ZsL������K�
����R�G
��u�_N�Sv54�����/<X���Fsv����G+�!aW�[WQ ��@��k�����6���v�������n��* @������c+$�

a�*T�I�
X&�Zl&G�W@��o��+ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4����}aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L@����ve�
,�
HF@��L�J *
aWT�P
d* ����������U��&v�� @�
��]�
u�]u��C�
�v5�i4e������+�
`� @�@2��dZ�PQ	��j�b @ S
aW����V�]�r�7��+����
 P& ��/�# ���� �����YO�(ve�/�]�o�'@�
�v%�*��J@�U;C�
�
�2m�e�* �j�;���]��DE @��2
a�}A�@
aW5� @��f�]�z�@���+�}!��|X>
 ����+�V)�@T������T@��i�-�U
aW���M&���'*"@�
�	������9�
4+ �j��h��]��aW���	 @��d�]��J��vE�� @�@���Lo��
�Z��o2aW|=Q
 @�L@�e_ PG@�UG�9 @�Y
aW��F#P& ��|_�2��O�
$# �J�U
%���+�v(�
2ve�x�nU@��*w|�	����� @�
e�.���:��:j�!@�
�
���4�2
aW��B����| @ 
aW2�R(���]Q�C1 ����+��[v���V���L�_OTD�
(v��v�Qs
hV@������	�2����7�� @�
���i�B	D% ����!@��L�]�6��[v���d���z�" @�@����� @�������s @�@���f=�F�L��aW�����Z��p��n��V���o���k�N;�=�L���g�PR1���F��/���~vU�r
 @`���57��v%�8e @�@��]�j��D$����_M�a���i:k�
P_�:B�v����U?l�����S��8��t�QM���*��-��y���o���"��aj�C����c+���� @�@�����s�1���������]�
:�
,/ �Z���	4v�\��5��K����h�r�_����k�5�vBon���^Yx��1e�
�]���Q�v�w�
���?����C����C�v-�p @����]k��p����2l@�Kv5j8 PC@�U�)X:��qt���]T'UPr����>|:��M_�#NeWnL�c�3�M�	������a�����<vqA a��`'@�
�I@��&���M��.��,�\a�2z�%@�
���q4
������j�xT����'��*+�=~�`K
>6�?
��S�{�]Swea����S�X��y�{����1l����������m��������p�������u\�g�A�\��1�jl:s�M�D�C�B�T�3�$4Es����*B�"74�������#D��X!�2��$��6v����e���=3{f����Z�Z�y���������{>�g������v
��\�
 �Q@����
2��5��C��]V
����k�=PA���\����:�x���@j����i����B��w{-3D�J�w�=Y�~����@���/Jv����I�
�]@�5�`��	���9�
�v��4�z�aWM��x��EL�EP��6,���w�E���`���9�������x,�E��}h���'�����[
����^|������o�qM8;;K���%����R�_���3S_lO�_�������g�}v{E��R������(��j8 �B@���)6�v�=�}�g�����a���w"m4�y�tRem7B�u���:~��1�{Db8����,S���u�{7���?�G�_��-��_~9���K�mo{�F�&@��R���~:���+�4*��h�F-0� ��]�v�z�?���w�O��+��l�I @�@f�����,:�]� �J]���`]��T�����6��Z]����Uq�_�y6Y�FW��>��S�]��G��cn������g�
�f�~0����o"�1�M�C�
����n��W����|��f(����� @�����1�	��v���������%��5Us\�����B]�5?}����\�wP���j=��wM�����yM��1��uvS������Zp
 @�
aW!�Lz����6K�8aW�=R!
�/ �*��f�}��a��G�]&`�C�������cW\hq�����]5
T�c��}�\m���������z���#	Wp���Q��cWq�����h` @�@T
aWTN��
�������������'@�
��]�
�@`�@���< �^l��o<:p��.��z�b��kx�N��co��k�3-���������y���\~���^Mm�-&[���5+@���G��	 @�
i���C�U$��+|��	�av p����!��@��k�����M�����w9-x+�n��@��_������{����!@�
���t:
�<�Lx�;���\w�w�5Y�U^O��
�v��3�'�9��M�jCTt=Z�H�������]���D @�����Ux����]B��P��+�! @�@G
aWG@�h %�jp�$* �J�1�"@�
�vY�v�Qs
�+ ���i4u����a���� @�
���i�B	$% �J��!@���
�F�x�T B�u����v�����A��b-�]-��F�
X@�50�h/gWZ��]�u�| @ G
aW�]Ssn������O���q��[U��s�N��$7���+�_���
�S@��g�r���.����W���� @�o
aW���'B��k���*�:�l��T~�������+�)�
 0vY����o<��]���"
�) ��&�/�1�����y><���kQ������X���:_A���� @��A�]�0��"�w%.aW�]5'�M@��[������+��E�Y��P @���]=�z! �*q)�J��9 @�@n���:���]9v-b������"@�
�( ��������������
d# ���U
�L�����G����F{�������^�]���
 M@���@+fwv����@�]�u�| @ G
aW�]Ssn���:�^aWdP� @�
zv�k�%
aW��A�UbW��
rv��1��(�1��q�j^vY @��<�]y�I�Rv��� @���]c��9- �Z<��	�k�r @�
+�]�
m�]m��C�
�
��z�@�@���x'��{y��Q8;������+��(�
 pC@�eI)`7�v��v��kt �D@��D�1�	D���`�=	����0=�\UT�\;����p:=��L����0�u�\���]� 
C�
�Y@��3���w�-aWi5�Q@��c����@��kz0	��&���z�q���7K��� l�U�\�_��V������
 P������&51�����aWF� @��N��N|N&�H�c�udM��0��������<}.��'m��9C$�B�5 @�
��]�
��N��n�P��v��55 @�@i���:j>)
t����v� �t��^x{�����k���;�K�����]e��� @��r�]��2���������	���9�
�v��4���]��+u�E�vmK�u	 @�
�	�6�rt�M�.��6��8G��
u�$@�
��]V��:�]
s�=]�w���]-��F�
X@�50�(/gWb��]%v�� @ 7
aWnSo���6~�q�J�,�*���F�
% �*���N��.���.L����� @ ���+����vUqW8���GO��q���&����]��7u�{N��a��	��k�� @�
��.c
��a�����k8kW"@�
��]���"�]�E���Y�u�k�(�]K����+4v5�r$
 @`���m�����w��\�UN/��
�v��;��#-��g�*]vY @��<�]y�I�Rv��� @���]c��9- �Z<��	�k�r @�
+�]�
m�]m��C�
�
��z�@���k��B�5�`� @�@6��lZ�PI	��j�b @`����6��v
�����]��DE @��:
a�uA�@
aW5� @�������F#P' ���v�|
�>
 ����+�V)�@R��������k��7�A"�]�a� LN��p2�\������S	 @�

��v�J����e �*���A�
9�r���s�vM��d7L���~.�W��� @�
�! ���O�TiWJ/�]�t�< @ g
aW��S{��?�,/b�u>���N�����+�5pY��+�6)�
 �]�6����������F#@�
m�]m��C`3��a��1�������������st�����
O�
�$ ��i���w
��?L��|�H�
#v�����u��a�������hN!@�
lA@��t�$P�����&�
d/ ����&����+�&�Y���O]c @�
�	��Y����]c��� @�@���T;���"�]�u�wtV��k�gar:
����������>�
 P������7C���z�yE�����A�
b�b���m��a����'�`�����+���$�V��tz�]i-CaWZ�P

 @`�����Z��nh�~�'����� @`
a�&Z�%�N b�5������Y��0�v����v�:�
aW?�F%@�
�v�5���w��aW)�4�Y@��s������+�N�T���'X� @�
"�"�n�����%"�*���A�
9�r���s�vU�o�����(�_����W�4�����+�v(�
 �R@�eq-`7�x?�v��jT ����k-�h'5�:\��pr���p4�����]�uD= @��z
a��1��������(��ojD ����kS1��\ r��y
�����k���N�
h* �j*�8��]�
����k�=PA����{|��]#_�O�
d# ���U
%����+�v(�
F* �i�M{P��a��~���!��3�(�A;��b���P#@�
lY@�������wEt]�UDM�
2ve�@�g!1�����n8�?
��I�Wd�.��
 ����+�>�S��])�v��I� @����]9wO��D�f//~><8������)�� @�
��2iT1e����JaW)�4�Y@��s����@��k���*�:�7v��~wv��)� @�
cv�}=���������/Y� @������V�$�V b�5+���m#�u��nK�u	 @�
�	�6�rt
����C����>
A�e�_�c�u��GO���<��	�����v1 @�@k
aWk:'6��kL��������T(V@�UlkM,!��aWB3QJ+
aW+6' @�
v
N�����a�`N��a�PYJ!P' ��. @����]���
�v���;g(��0} @ 
aW:��VA�nx	����JV�� �}
a��{���	~0b�u�w����fg��h��]b�
 @�������Q{���������g�/��M���]����t/o��{L����� Lv�kOj�;
g����(���{O�tq�y����{������aV���Y5����S��z�ppa���.E�
V�,��R�����/i#�]�1�7D����O=.6�ay�WZ�����+�~��
����z�5�����E0s�^�79��`�r�Q��8�br{?S��9��	����4A�U�u�z��\c����.�5�O��D�1 @�_
aW�����z1��
WK<^������OG<��t�6L��_�����c*3v��	u @�
��;����������������]����z��������wi�P�pt6������p~X8��k�����a�"4��lit9��]a�<���.����:�9�
DvE��y�N�U������U6��o������M�{"��1��m��j7����c��Y�A@�
� @��
������������3�L�_����M�������M.-x���w[�v��#�s�x���c
oWKU�������C��x�Z'��@�Qws�����Z���	���5.
h. �jn��#���9|��_�f	�����{O����{�O��#�]�����\~~c��[����VS���
o�� @�
��.ZY��hv�z��w{�����`��{�j��<8�-���+�/aW)�4�Y@��G���|����vU����;v���iz��������U��+��q @�
�
���]7������]5=\���d�N��wv-��:<�w�t���^:�
����J @`���<z?�����
��X��\vY @��<���{g���b\7�������>���usE,?�bR}s�;��O�������0���GC�k�]�
����k�=hR�w���o~�7�:�1�����������^��]��
@a�`�2�	����� @�
7���o��[��U���2���X�I89Y��k:{�I��-6�w��U��?�0,������	��YceU*�*��fC�
y
���[�U���
��a��c	W��v�$���YuL�+d��	�F�v�&@�
2v]4����2�zr��{��k�w����O�����<����t������=��� IDAT�����[�����N��.���jX[��k-� @�@�����Gv��{��?�1��*p����jJ @�@���"�jRzv�N� @`���k-�6hvU���
��>(��h�w������
 P����������]}�
�v�7r��q���3��������|aW��$@�
�v�75�
��"�����6�
d. ������B b�u~�������y����/�'@�
�ve��B
��+��A�UJ'��
rv��=��"1�:�^��|xpV�3���3�, @�@��<�TN��w��R�UJ'��
rv��=��"1��}�������p����)�� @�
y���S9U����KaW)�4�Y@��s����@��k6e�\Q��+����
���k�������������X��!@�
��]���I��@����9���4��^8���&P�#���� @�
��]����X���1UF
�2j�R	 @�X
aW��5��:�]	�D)��]���D�
\@�58�(B@�UDM�
2ve�@�g! ���M�)����� @��������"0
a�xzm� ����+����
aW9�l5aW+6' @�
v
N���v�F� @����]�7P�Y��hSE
���52
 @ ���+����G@�5�^�)
�+ �J�7*+G@�UN/[�D����I @����]7��������?��0�N�d��X�TcN&a�����3�jpA��]��I�
�v�%;�qc�w�����������@�5��a���� @�
���Z���������]�`����+�1��0�}�����wN�5�Z6�H�cv����L�
�	�R�H
����4'�=Q���r�7��Q8;���JH@��P3�B�
�C@�u���&7��}�d��:��f����p�������c�����{I��}M�

v����k��d�|�D�����=��.>a��!=�M���+��� �J��!@�
�v-d��Z�Z�^c�~�><
�����:�:S\��a�e���I���{h ����+�&5{��vt��6����l3����|����W������Oj���a�8�n� @�@~��E���������p=�Z�TbvE9���)�����.���W,�Zo� �����o���oO�G�u>�|�wro��\l2�w7_}]|od�.��
�2h�	 @�
���k��m�f��:����������^�a��]���J��9 @�@n���:�x��D��]�-���!'���9��k�	�r��Z	 @��1�v����L��'?��[����#?�#�k���G�wy��
���e�]=��
4v5���a?��?���/m�����-���������D
���1�5W�o>O�����o<��A=X@�50�� @�
Z
�v}�c����ZV��ioy�[���o����3�1����x�[I��%x�%@�
K��<����v/��bR���������S���AW��]��^�a�J�
a�V�]�
 ��@�a��m�/c�����V��\T���  @�������o
�����a���+���OS�_�����$
�R��� @�
������xG�����c�5��T���i8��:����;�����+G�U\KM�
2ve���K���i2N>{��a�� <7�6�Ks�L�?�z����!�]?.��2���]#i�i @�
���Z�x����Y8��j6i���v��pZ�;�������f���jN ����+��ePo��N�q2�u���j�B8���r�+����������+�&)�
 P	�n,�����O/�.q;�r����V,��kf�Z���n����]%v�� @ 7
aWn��^{�k��vU*�������dQ��La���o� @�@V�����m��w��ne����zjF ����+���8?��aW~SV�����z @�
�! ���O�$����+����
�( �c��yh��aW�L������7v5���A���Cw~5���aW���'@�
�v�qL}����;�K/�T[�SO=����.����z���]O�[V��U~'@�
s
a��@ ������_��Wk�v]<�p/�U�w_[����O��v@tvut:
 @` 
a�@�[������}����+��r��Y���O~2����|x���[���1l�_����vE�4
h) �j	�47~���=����
�}�ko�t�f#N&a�����k^����:�=
a���]�
 ����k�|��������?��8==
?��8|����u���o���kq�X@��1� @�@t
aWtR�T�C�`8>>	�{��n	D	�.G=�;�O��kB���#�i��j�b @�
+�]�X?��6��O���;���?��av�W�a��]YkM�UV?��
�v��7U�'��}O���	_��_�s����U�F@�e� @�
�v����U&vu����v%�E @����]#_�M@������]���� @��2�]e�����]�����v
��Z @�^@�ee�# ���X�(��"�jR @�@����Z3%a�8�<�,�]Cj�
vY�m�u���{���0L����wB�������q��8��{�j��m^���s����F]����1�=��J��T�q @���
���?���'"����D������?���{g�P��p��{��@5��{��%F��}����s*
�$���.��Dj�a����>NN�Fx�k_;���/�x9������Y.Obz&����j���wNj��yH��Y�9Y�q�;:��M��d7<
k��������3�C��N�a����{��6}v�Qs
 @`x
a��������	��]������?��S��~������'����(-�k����.�L���'K���}�lVM���}���3��O����U
�P�m����.S�S����g?��5��u\���
fv�������]���{��b��a�V)Q��O��jrW����E�6��n�����T���T���;�f���_o����y��v��s
 @`X
a�
�w��Gl0N�O���ZB��������o���������SW@��3��O�5���K @��5��.��XX6&��o ���nRe�c[�]+C��\�������<��-�����a�|�]��|<��T��M�O�
����k�}��2K!V��-T�4�4�v�D�W�#����n����c��'~���j�7��paF�>a��U� ��@��kEY~���_�\����|���19|0J�u{�5�ao�#{ZAw�]���P=��z������]L��qq�����l�y��j�1�/�~�a��^�F����3,
 @ ���k�������������p)����,�����fu���h�'�Z�j@�
z�v�}��~eq
���(a���?�������7�'������.���n����]M�;����������g�_DqA�y�]_(�j��F�
HD@��hD�;j���3+c���Y4��Hsw�����ZF���zp|�����	�:� 8�
D�v�}'JC�����=���8�|0b���
��V�z�1�
�>7=�o�������n1�;���N���_�����6>�������n�
T�%���3<��S��W_m|�	lK`ggg[�v��fw���mo�>�lf�G.w]�0{/o�')49�����tV�y���@�������C�
?��������l��W�r��k_�Z�g������������ @�@L�/}�K��������a���1����_sI����I�c�`m���]7�y��K�p%mv-%�m7��6TM7���������������|o����$��_��0������g�!z���=`W\�@;
�A���X�v�����[��_��U��?d����v��}�i��6��?��zJ���>��KpW;��:o�d�Z��7�s���t�����s���-�����>�M��M�.#@�
�^z����/9��[E��;�������w5��w,�e�X����@f�$�
��aW����Z�����;��������=�K�z����&�a�8���71���&J�!@�
l_���~��_/����'�T��;O����7\�i�������q�I�E,&����	.�����W���cb}�5�}��F��0
h)��1�~�i�^�i[����$?1�J����]��P�o����X�f��[��j~L5��i���T�[58��17~�xvSWu����]��ej @��}�]���Px��?���;�y7����faW��u6���O�&%��4�w�fxm�V��&��&���69��1����]1.�E�
�	�������Y?����g���-����o{��������h��v�~��b��U!P?�^7jm���K����\\��j�q��
�����uA��Q��B��-���y���������[�#
7y��*'wv�[A�O�
HC���+�Y6�"��:U���Iw}��A�y�����r��m��O*���xvp�}W�cr��	���	T5
�%�.�����W���:>���+�������}�k�>��u��Y�5�F�f�il��
����sp-n�[>�^�F��s�o<�v���������k��8���om����I��;��	�Z��$ @������&w��:f���=�a���������]0��]��/>�����������}��kk?@.L�
.Z�]~���V	�`�L���&<�v��;�,�d�]��B! @��;�]K<
���sGO�O��v��Ji����N�
�,�*��y�j�Y �����SM%�F�z���{v��jP @�@t
a�
�w��G�k�M>M��$G@���( @�������sk|���k�?+���/�'@�
�ve�*�HJ@��T;C�
#v���}O��	G��?�b������������N������u��vY @��<�]y���*��J�����.�
�. ������A j�u�����pv<	������k�H�I������0���Z����� @��*
a��1�������\O����Q	 @��&��M�K��@��k������������faW� ����+�Y���q5*
 @ ���+������+e��J��y @�@�������\�]�t��:�]=��
 Y@��pk�]�,aW)�4�Y@��s����@����k�c���z�����]I�C1 @����.�ch
���������W� @��M�]�h9�@;��a���
���[������
}�& �J�#�!@�
��������7�EaW|S# @��M�]��9���q���A��>
Oj�xm����v�o�
 @�������H��n#�Tv��u @����]c���)������E���`�M����{��lh�k	���9�
 0���k8kW�	�����]�t�< @ g
aW��S{.����2}u
��
 @�@��<�TN��w��R�UJ'��
rv��=��"1��}�����x'�L_��.k�
 ����+�>�S��])�v��I� @����]9wO��D��)���>����+�% ���O�$@�
������'�����>T�I�
6vm��hm��]��I�}�dE{���zF�*������7Z @�
�
�npV�	��r��������z�,��}V�p�=<
��ka�Gxk�	��F�� @�R@�e1�"�u�sQ�]�d�'�v���~?T�V�l|e" ���Q�$@�
F/ �ZZ������c�����(,^���[y�
_��9-���w���#�*���A�
9�r�^�����4'�=Q�������[������]Y�K� @����]�_[��p��)��''�,�1����`����[��������
�J��9 @�@����;�Z���;M��gO1�����?	/�����u�z�]�
�@�
B@��P�j-����4�=Z������_��{D�����Z���v��!~������cW @�
��]��|#
{�Z��aW�I��~����h�%~��+�)�
 �v- �a�4<����O%VaW�cn=�}l�������n�]e��� @ /
aW^�J�Z{�����OR.�"���F����n(���c�%@�
�* �jv���U=mb��@��1��0Y^p#���zn��]!��
i�i @�@������^�������&����D���J��*�[@�e� @�
��;����������0�}���S?�S�k���n����S���.��
l_@���4���������/49t�c�������={����H%"�*���F�
�$�w��������
S���o����x����(�������OIL-�]�
HQ@��bWn�4���>����}�{�<x`O��+���������z�gar���
�sH�����]�
 E���+J�C���1O&a��dd�f��bI�}
wv�-l| �^@������bE
���w��P}��x&�az8�B�o��qz���������q5*
 @ ����Bt����*���.�1W]��u����F������S����]�qwU �, ���
���4'�=Q��k�����������"�:�������h��]���M�
J@��$=o�I8����k6i���_v������g�����6>
X/ �Zo��
b�w�����H���*�paWi5 @�T
a���.6e��7{��<����u���{��I�5J]p�>����9�Y��s��N�
��J�db����i2N{��aWu����^����gbkc�����us&@�
rv����k���������Y @�@�������<��]��+�>�xk�{#{�s��U)���W*%@�
�- �w��3{��������+��� @�@
aW5��L r�����}
a��{� @�@
aW%� pS@�eM @�������/1��}�� LN��pR>\)3v��I� @�
Jv�����g�ZG��#�j+�< O@���HV	D��_Z����R�zys�L��o�TN�
�K@�5�~o��w��A�
�]q�B�
����9��j���_~3b��t�iu����p�{�����zv%�� @�
�	�,��	��m�>���]1�A�
�	���9�@�~���+����'�?�Gg��0�T����]�Q�
 @�������#	��E�pa���.E�
V�,
��vM&aw�lCaW����
�����A�
����k��yS��.�5!���g*&@����]������'�����*�::�n�J��UE��$��( @��-
a�E�5
��������+��1 @�@7
aW7?gh"1���&��#�J�#�!@�
����a������j���l�L�
�
��J9�@{��aW�>���09���I���9���kXoW#@�
�v��s^;
��vn��%�J�'*"@���	���s3^ b�5|���]@���� @��!�]C(����]���� @ ?
aW~=Sq~q���r���Gg�'��)�baW�-6A @�
aW!��i�w9uke���"�h ����+�*?��a������pv|=�:��	���?�BD�� IDAT��"�]�7�� @��b�]��2����e���e
��9�
�. ������a�������wp��=]����k���M�
h. �jn���w1SC��B�@�
cv�}����!����+��(�
 �$ ���v
�����]���
4v5�r����V=��c�7��3�]}�
 G@���(����[�|��+����
�" �K��s�Q��*��ex?����^8�}��6���3
a�u@�
�C@��G�������~
�J��9 @�@����;��"�]9LY���.��
 ����+�>��@j���:����k�]7��"�]�O����4N�����v��s
 @`X
a����fW�v��I� @����]9wO��D���`���g���r��:�]�
 @ 
aW}*�J��Rz)�*���A�
9�r���s�v�Oy�K�s
[����u�|	 @��\�]�v.��������zaW�=4�_@��� }��a���_ �������MFU��kT�6Y @ c
aW����t��,�VS����N�
�, ���{j�E b������, �� @�
y����*	�& �J�#�!@��1
���usZ@�5�xb�v%�� @�
V�,
����9�
�v��4�:��a��~��R+�wtV��KRv��� @�
��]V���w���qAaW��$@�
�	�6�r4���?�<4b�5
��*�:
����Z���[m�N����w������]}��
 W@���h����	��}aW.�R'
�, �*�����@��k���������fw��R�g��q���	 @����]��,�������U���R:i ����+���=��a���U�u<
7n�
az��������+����
 P/ ��2�������	���52
h* �j*�8�"�]�"f�������fA�n������pg�v�q4

 @�o
aW����-`W��v��Es @����]�wP�9D��7B'�f}/<<������) ���i, @�@���l�\'`W��v��I� @����]9wO��D�r��:��]�
 @ 
aW}R%���]�uD= 0F
a��n�C�
���,|���b�z�a����g�zw
�, @�@��<�TT��wE�S�UDM�
2ve�@�g!1����x7<���c�V���v��)u @�
cv�}=���������/Y� @������V�$�V b�5{���������b+�	����� @����]�9����]'��Nv%�� @��h�]�m��(1��}�����x'���:	�:�9�
 0���k0j������]�t�< @ g
aW��S{.���~�zg�<�:��<���+�>��
  �������
��P5&
�L@�����	��vM&a���u��#�8l��^�v��kp @�@4
aW4J5��k��a����<���km6�-D�f�t��D+Www��C@��G�TI�
vY�
��
�����]���
4v5�r�������wo����vm
�%	 @�
-�]-���A`v��uL�TaW2�P
�X@�5����`���]]�����4za�`
�z!aWWA� @�
�v
��*W�we�aW}4�[@��w�T��@��+�i8��V��i�J��X
��,��H @�@vY���
o������F$@�
�
�6s<��"�]��t?YY�^�:����ktF���q
M�
�( ���i��w
��8D��E�I�
��
o��%!1�Jb>��P@��!��	 @�
[vm	�e	d. �����'@��"�]E��$v%����v�-l| @�@
aWG����kl7_HQ@��bW�T�@���������=]s���v��55 @�
cv���C���nh�!�'�B�5 @����.+�@����t�~�]���
 K@�K�8�% �W���
�v��U�/�����I���g��:�9�
 0���k0j"P�����v�
d* ���q��J@��U��+��ojD @�@��>T�I�|
aW�=6CH_@��~�T����+�v������	 @�
�	��v!E	��j�� @�@���L����]Y�+~�����F$@�
�! ��C���v��c3$@����]��H��t���`���4N�������Y���]F3a�hZm� @�@�����E��wY�i�"�]�9�
�  ��
��nD�v��'M\��� �	�����v1 @�@k
aWk:'6��]�w��29P��I��I�
E��n��%"�1���bvG��p�vB���D[8@��t�$@�
�v�@sJ
��hI�"�J�=�#@����F�h���@����~�1�j'[^\���i @����]���r�w�,
aW)�4�Y@��s����@��� LNg���e��vY @��<�]y���*ga��]	�v��Es @����]�wP�9D����>=<��9L]�3
a�u@�
�C@��G�������^
�J��y @�@�������\"�]�S>��	��Q8�xe��]Y�I� @�� ���!`�
���v��4
h# �j���	D����x/�U�lV��{v�lx @�@$
aW$H�4��k��a���[�@���kM6��D��>�v�@s

 @`��-��$��]4� @ {
aW�-4��]4���]}��
 O@���H�$ �S���
Rv��u�$9���������^�?;��i8��DW�\�]e��, @����]��8�������+vmn� [@�[�xnD
��^^<	��0=��]!L&a����� �Jk
����j @�
��]����wC��s=aW?�F%@�
��6�r,�v������������+����+�Y���q5*
 @ ���+������+e��J��y @�@�������\�]�t��:�]=��
 Y@��pk�]�,aW)�4�Y@��s����@����k'�G����c���z�����]I�C1 @����.�ch
���������W� @��M�]�h9�@;��a���
���[������
}�& �J�#�!@�
��������7�EaW|S# @��M�]��9������������$�>z����tz&7/v�v�/Esu�59�nM�[s�e�������-�+��W���! @���]	4A	2ve�4% @�@q���ZjB�<~����2���A��>
O��ho�$���A��i���z���c&��QX
��sG��i���OR�N�a���>
��1m������s @�
���7wE%�J��9 @�@����;��"�]��������*��ARM^8�*%���iQ�d�~���+.B��<krL����������;��i�w�����_�s����y��v��s
 @`X
a�����Z����6#���]Q
B�
:	�:�9�@#��a����&W����
5
w$5����j��k������I?}XH���v|�8�.d�5�sw�]s�����3n�)���� @��-
���?�K���Q+�MU���@ @�����5�	4�v�>�W%A�������L�nw5���k������WU�U���+�j���k2���c����
�b�4� @�
�v��k��@��;}�\@����3 @�@l
aWlQ��-�1���	�|xpV�si���
��q����jV��k����i���C���^����6�J���.����{���]_(�����C�
F@�5�������n��i7{aW;7g @��������"P/ ������ +����M\���u�y�{7�A�������z��k_�Z���������!@�@QO=�Tx��W���� 0n��~����o{x��g�
a�=
�z���������0
�vY�v��]�*4j����/�:���;���]�-7{�Xu���=b���u�{7����im����~u���Im���
t�$���O�W^y���
K������������7~���Q�����mo{��+���n�J\���jN ����+���7G�a��p�h���ktp��jc8���0Y�FW;�����Ua��c�_Tv1H�c�������n�6�J���hK�@ @��K���W�F���~>����/GS��h�Z)p�Jy�y��67s
�- ��-j<��v�_�����Z�;kTU��i8�49�nI59��17���16�����h�.?� @��4fa�����:����?*�{����o}��[-�j�����]qer��+�F)�
�v�^�KD�c���,�(���������$�]��U@58f�(�G!<�d�B�������D�&�1\E������
	 @���fa��}������?�V������-��-�&$�j��$�v�~	 @���]	4A	�v��U���[��kJ]vy�{�����k)L�2�U	�_x�*
���?�7{�b���X�����M�
����n
�%	�vY @`�����@�v���x3v��4
 @�B@�e- ����+�N��
�, �s��}(
a�P��^G��hc�E�
d- ���}�'P�����v�
d* ���q��J@��U��+��ojD @���� @ 
aW*�P
�Y@�5����P�������+��(�
�Z@��u�O�(
aWQ�4�T@��i������+�v�/V���� @�
a�5@�@*��T:����k��7���]CI'zaW��Q
 ����+��)�@Q����i2 ����+��);+
aWV��_��+��	 @�
�.k��T�]�tB 0f
a���o�C	���N�:��D�, @ k
aW��S<���]E��d @ S
aW��SvV�����XaW|S# @�
�]�
��R��: @`���1w���v
%��u�]�6FY @�@������xE	��j�� @�@���L���?~|Y��+�v�[���__� @�
�v���fM E
aW�]Q
�M@�5����6�]�PO������� @�����O�_��/����6��O�Ix���}��hc����]���	 @ }
aW�=Ra����{�i��N|N&@�
& ����% �*��&C�
�
�2m���ve����
����
 �����Uc(_@�U~���
�v��#�/ �����f ����d @��`����]�@Q����i2 ����+��);+
aWV��_��+��	 @�
}��P5&���]���	 @ }
aW�=Ra����{�i��N|N&@�
& ����% �*��&C�
�
�2m���ve����
����
 �����Uc(_@�U~���
�v��#�/ �����f ����d @��`����]�@Q����i2 ����+��);+
aWV��_��+��	 @�
}��P5&���]���	 @ }
aW�=Ra����{�i��N|N&@�
& ����% �*��&C�
�
�2m���ve����
����
 �����Uc(_@�U~���
�v��#�/ �����f ����d @��`����]�@Q����i2 ����+��);+
aWV��_��+��	 @�
}��P5&���]���	 @ }
aW�=Ra����{�i��N|N&@�
& ����2�L���'!�{N��ar�����s���O��krL�K���sY�|��ptv�o\�x'������~	�2[��%@��"��]~�)rY�Td
aWd���v��1� @�
cv�����R`z&����* ��;	'ua�"h�;:������`������1w]�����
�N���J���V8
g����8f�!��T�� @ �@����;��a�b�]������]��E�
����k�p���@h��a�V)Q��O�`kR=
�y�����79��1�=\;��i�w�����_�s����y��v�Qs
�+�:���N�F�h
aW��]?9a�z#G @�
Rv��5�*Pv->	}j-W^�I�s?LV
����w��yL]�k������,���}<c�f�B9�
�(�:�Z���;=6��E��hc�I���9�
 0���kHm��M��?��O8
�����WU�����I��0��>|a�c;>��b����V�z	 @�D����X��d��N�k��6vmnV�����i2 @�@�����kj�Z�]��vN��]�������\��6�z�X�}�d1�^8:��<���BaW�ee M`ka����z`rF��Dk���ve�������
 0���ke��U ����M\������2���E�>��O��|�3�-|��������\��n ����/�>���������sy��g�dr��9����20�?~|9������v��-� @�
cv�����N����T���cX���p�N�������������]>��O�/~����f�q�_����;�c�� @�
=	|��_���WZo|��7�7�yu�����# �*���&"�j��, @�������]/'�l_�~x��������f�~09
���7�}]���k��� @���z{������d�!����@f�����p��cj~'�>q����c��}���B����c���q
M�
�( ���i��j���{����Z��j�n��t:
���#�<����yM��1������f��:�v�\M�
F(�[�����&S^% ���v�|
�>
 ����+�V)t�a�<)�����w�i����1�G	>
��< �L���}�U�����1\����-,H�$@�
7����c��v�|-�F�L�
�F@��M�:��<�:Yq�����a��������5���]�s#�}U���^�l�=9��{���=jh��k��2 @���a��w,+��]���<R�Ud[M�
(P@�U`SM����
�]�
�hv�%@������U�G
��l�I @�

�
l�)@@�5�K @�
a�5@`�����`������ @������R�#@`Y@�e= @�����k�=PA����{|��]#_�O�
d# ���U
%����+�v(�
F* �i�M{P
a����]L��^OTD�
�vY�v�Qs
�+ ���i4u����a���� @�
���i�B	$% �J��!@���
�F�x�T@�5(wzv�� @�
��]�
m�]m��C�
�
��z�@���k��B�5�`� @�@6��lZ�PI	��j�b @`����6��v
�����]��DE @��:
a�uA�@
aW5� @�������F#P' ���v�|
�>
 ����+�V)�@R��������k��7�A�]�r�w1aWz=�-D IDATQ
 @�N@�e] �F@��F�9 @ ���+����	�F�.�]#_�O�
d# ���U
%����+�v(�
F* �i�M{P
a����]L��^OTD�
�vY�v�Qs
�+ ���i4u����a���� @�
���i�B	$% �J��!@���
�F�x�T@�5(wzv�� @�
��]�
m�]m��C�
�
��z�@���k��B�5�`� @�@6��lZ�PI	��j�b @`����6��{x����5�]�s�}
aW��Q
 @�B@�e- �F@��F�9 @ ���+����	�F�.�]#_�O�
d# ���U
%����+�v(�
F* �i�M{P
a����]L��^OTD�
�vY�v�Qs
�+ ���i4u����a���� @�
���i�B	$% �J��!@���
�F�x�T@�5(wzv�� @�
��]�
m�]m��C�
�
��z�@���k��B�5�`� @�@6��lZ�PI	��j�b @`����6��v
�����]��DE @��:
a�uA�@
aW5� @�������F#P' ���v�|
�>
 ����+�V)�@R��������k��7�A�]�r�w1aWz=Q
 @�N@�e] �F@��F�9 @ ���+����	�F�.�]#_�O�
d# ���U
%����+�v(�
F* �i�M{P
a����]L��^OTD�
�vY�v�Qs
�+ ���i4u����a���� @�
���i�B	$% �J��!@���
�F�x�T@�5(wzv�� @�
��]�
m�]m��C�
�
��z�@���k��B�5�`� @�@6��lZ�PI	��j�b @`����6��v
�����]��DE @��:
a�uA�@
aW5� @�������F#P' ���v�|
�>
 ����+�V)�@R��������k��7�A�]�r�w1aWz=Q
 @�N@�e] �F@��F�9 @ ���+����	�F�.�]#_�O�
d# ���U
%����+�v(�
F* �i�M{P
a����]L��^OTD�
�vY�v�Qs
�+ ���i4u����a���� @�
���i�B	$% �J��!@���
�F�x�T@�5(wzv�� @�
��]�
m�]m��C�
�
��z�������/1�]#_���/�'@�
�ve�*�HJ@��T;C�
#v����=���kP��.&�J�'*"@�
�	������9�
�v��4�:
a�����k���	 @��l�]��J��v%�� @��H�]#m�i* ��;��	����� @�
u�.���6��6j�!@�
q�]q=�F�N@�5�u!��0} @ 
aW6�R(���]I�C1 0R
a�Ho��
��N�b���z�" @�@����� @�������s @�@\
aW\O��v�|]�F�L�
�F@��M�J )
aWR�P
�T@�5�������A�����+����
 P' ��.h# �j�� W@���h��]#_���/�'@�
�ve�*�HJ@��T;C�
#v����=���kP��.&�J�'*"@�
�	������9�
�v��4�:
a�����k���	 @��l�]��J��v%�� @��H�]#m�i* ��;��	����� @�
u�.���6��6j�!@�
q�]q=�F�N@�5�u!��0} @ 
aW6�R(���]I�C1 0R
a�Ho��
��N�b���z�" @ ]�O�����}x��g/R�58�(B@�UDM�
2ve�@�g! ���M�)����� @�@y��G��}����|�#�ON�58�(B@�UDM�
2ve�@�g! ���M�)����� @�@y����^z����w��rrO?�t�K�/�>YaW��.@�H
aW�m5)�L@��Y������+���+Z���H @�@�{{{��o~s���w\N����
�����'/����) �*��&E�
�	�2k�r�ve��xE��Y�
(_�c���(M@�UZG��
rv��55�& ���c��vE5
 P��������"�]E��� @ 3
aWf
Sn���,��haW<K# @�
�	����r��>������=o����VN�G�G��?����~p��z����.H�
aWm4	�\@��y����h�����p���G{���8�_|�x?�,x�a8�����69o�1��I�}�dq�u-�t>�i��jjv�k�� @�
%�����}���������w��INY��d[E y
aW�-R 
�@@�5�&��V?~|y�q�]�(�U����E�wt�����nx��KM�[w�� Lv���t�dmj����1mV�����s @��R�]�t�<X% ��6 @����]���
�i���&w�]+��L���2��H���������������f����/�����0��a-��]-��F�
! �*��&A���.��
l_@�����|
a��;�V�Z��V;��������y�_�-�����a���U���x�:v��Cn� @��j
a��A�@����;l~ ����+�.�1w�Q�]���NN��[�BXz/��1���p���F��+��yU��v��V?�0��/�#���GX� @�@
aW=� ����+�.��
Jv��a�KA`�a��T'�������,�u����v59�pv�
�cW/��.��� �����/v���� @`���mw��	�[@�����	 @��z
a�z#G�*0��k���6�n�-+b�U�&�k������[��O|��_���������k_�Zx����u-9�
I	<�����W^I�&� �����K���?�,�g��������^�UE������w�g�}6��E�@���4��*���k\�6�����/=��������.��T�T���y���;�B���������~��9|��_���������|�3�������]�
=	<��S��W_�it� P����������r:���~���o'9�_��_
oy�[�]IvGQ�v��� @��x�]����nO@��*���3�Q�,�������:���j�>�5�Ua��cj�>��	����[�?���������dYygW%� @�
�
x�a��5/.�]�
����k�=PA����/���p �������Z��k~Lx�NC]�U�o���&��X|�;�f7uU�^|K�U�� @�
�
���5:
�vm�* @�
�.k�@������k���x���U�4�N����]�C����*[
��7{�����_���Mc�j)����2W @�
�v��� G@���( @�������s	4g�5�9�N���=��-]�N��.��-��u3��f�:����������A/��?�7�#����w�aW�G @�
e
����Y p% �� @����]���
�q�U~s��P��D�1 @�@���R;k^\�� �}
a��{����]����
�F�L�
�\@�5�`�F  �A�M�
�v%�"  �*��]� ����\ @ w
aW�T?
��]��|�
�/ �����F��]#_�O�
F. ��0}#v����H�
���o�v��.Svu�s.
 ����+����u��uB�O�
�v�o�
�]#_���/�'@�
#v�|
�>��F�dS$@����]��H��
hb�)���9�
�]@��{�O��:
a�:!�'@�
���7v����
a���� @����F�L���]#h�) @�@����[���]4���]]��K�
�. �����'@`���k��� @����]��
a�����k���	 @����]#_�O`��4�	 @ y
aW�-R`��?��\��ic�-��%i @ G
aW�]S3
��6�r,
�G@����Q	,�F��]#_�O�
F. ��0}#v����H�
���o�v��.Svu�s.
 ����+����u��uB�O�
�v�o�
�]#_���/�'@�
#v�|
�>��F�dS$@����]��H��
hb�)���9�
�]@��{�O��:
a�:!�'@�
���7v����
a���� @����F�L���]#h�) @�@����[���]4���]]��K�
�. �����'@`���k��� @����]��
a�����k���	 @����]#_�O`��4�	 @ y
aW�-R`
����e
��.z�%@�
rv��A� �N@��N��	 @�@�����]���k�k@�5�`� @`����/�'0
a��l� ����+�)�
aW
M�2aW=� @�
��r���	X' �Z'�� @�
aW���@@�5�5 ��0} 0r
a�������kM6EH^@��|�X�����&v������s	 @����]�wP��v��} �����cW  ��v�|
�>
���k���	�@@�5�&�"
$/ �J�E
,@@�U@�LA��E�� @�@����;�~�	��	�>
�_@����+v�|
�F�L�
�\@�5�`�F  �A�M�
�v%�"  �*��]� ����\ @ w
aW�T?
��]��|�
�/ �����F��]#_�O�
F. ��0}#v����H�
���o�v��.Svu�s.
 ����+����u��uB�O�
�v�o�
�]#_���/�'@�
#v�|
�>��F�dS$@����]��H��
hb�)���9�
�]@��{�O��:
a�:!�'@�
���7v�q
<~��r���q���Y�F�L�
�\@�5�`�F  �A�M�
�v%�"  �*��]� ����\ @ w
aW�T?
��]��B���o����5�C����A�
Z�Z�9�����
�J;\�UZG��
�D@����c	�Q@���k?�c?^z���'����<��o~��A�

�B9�@
aW�Nv��Es @�
�
���9��\�]�;������/����3�\��O}*��u�[�# @�@
aW$��( ��������;�~ @�������s	�A`a����2<��s���h������[����V�;�
�v��}��]�
�A��u�O�
tvut:
��!��#�������
<h���_~9������~���N"@�
��]��|�@w
aWw��Gve�>� @�
�]
�N�@�������yx���
o~����K� P�������UZ����1x5����]�
HH@��P3�B�@/c�~�~ ������>��������������?������o������^�
J�
�	��	�>������Y� ���}�'@�
:
�::���r�>�����������}��>��?�e������W~�W��~������7�!��O���q�����?���
_������?���{�@(G@�UN/�$]
aW���2a� �.B�
$* �J�1�"@ �@�a���������K����G?�n��{g����^����8���s���[���>����~���Moz��k�������-
a����k���	 @����]#_�O`��<�p�{��o���W��_
�{��z��(Q@�UbW�)5
aWj�a���.G�
$% �J��!@�
a����ee�
������G>����w�s>��cC����{��L������y�IU�
�[z�)������A�
�`CcEc4��
����{,���j��FQQ�m���X��
���?������;{���r�����?0���}�wfv���s�]�q�.C�U��EvE���
@��c�.��h
������K��������*�����V[m%��fQ�%����6D������L�]%a�&@�"B��B� P�@ddW�H�v�d@�N�Q����E�9����6��A P>
�1,�!=���+��'{ �����(�.mKC`� 
�@��d��%
��4]Rar�A7I��8dW�3���F`����Y�f�Z��
O�U<3��@��]��X{dW�
J:� 
E�U.C!$��b�N[B� 9������4$����(~�����6cA� �
d�n!@�m��])*�[4�N�[���]��?i�bC�g
�A����]n�?�@v�|V �b>
H� s���O��@DIvM�~����^��]1���
@ ��]!/ ����+e�.Hd�wl�� 
�	 ���B�@v��ay3��!
@�
�.7(��&����Av�|�> 
@ ��]1���@v!�b0�I����]���#@��"����z�
@�@�	 ��^A��� ��/��{�=9��s���n�+7�C�,�W^yE�7o.�F�
e���P���C@`��f������]^��o@�t'����B�
�K�~���[o���S��7�,w:p����_/��L���5��� <�s�9GZ�n-3g�>�"@v��[ P$
dW�������� &/����=Z�5k����"���T9I� ��y�����y�ux(��+�e+*�%K�Huu�$����1�D������
��R.dW)���"���W���Ev�|�> (��;��+�C������3
dW��O��
dW����

�2P�k��v��c��MO8�7n������8���U�p@I1#�J��M�
dW����,�+���!�@	 ����0 ���@�	 ��_a%��Cb�+@�j���qv
W4(��������_n&���[����� Y@ I���<��32i�$� �
d�G`��-�+,�"N@ �����_]��oo��� ���K�%'hI��eY
p���E�
u�d�;� �\��u�M7+$��A�m�Q��f���d��k����z��rF���<y�>\��~{�m�v�d��v3�{��g�S��2��&�(Y��F�pN���U$["�"YV��BB@�Fn���s�,�u�]����gH2 L���+�5$@�i�����1
�2@v�����.�s�q�g���X����m�+S}��K����M�2jHoy�����&N�(���������^�z���_o�~��g�k���{��9s�<���2f���/��Ri�����x��7����+���
dW���+���!�@	��a��
d
�:
dW�+��

�2@v��}�������������W]u�4k���fZ�E�Av�'��0��qY��i����1t"�^}�Uc���u�I'����/� ��_���mQ IDAT��2����/=z�0��f����{��c�����-���^���]v�x�@v��0�= �B]>��BN��~$ �"QF��@y�L��)s�>]�5Ri����l�$fTJ��%�����~�Ln4���2%�0&����]]�v�?�0g�e;<���^�Z��m[�����'o?Lj��?o�i�����c����*&���
�����~%��{�l�����S������dW"�����N��E��Q>��3y���E�������%����[T�n��k�=]��2!}:md���yk��NW��x������o|�e�.�d�
74b�|����gJ�f
+����T�}SG���]N�sXE��>
��8H#8 ��r)�M�]Q�.�A�@v�^!��
dW�L�h�@�
Oum�$�g�J���*�-6r��}vm3��*)��R�4k���Z�O���)��n�.��,W/8Y������e�[l���|��2j���R�������e��RYi�P-��AvUUUImmm�951"��%r��w�9m���%Ux��y����e�]J�����~X���y�����Z����z/go�����_\.���l>c�v����Now����q���.�[��~]�r@w�}����v+�����]�e�~��U����1�m�_��:��Zyu�'F_j��%7�ow�v�ZY�f���i���1�
K�]v�'
��>�6>}W)�-�C C������� }@ Pv�
��!����4!`I -�*��l�4X������Mr
WEre���L=p��sZ���\'	e�J���]�����9J��hgD9��V��&
[W�]v=��c���.]��U�����"�~�^���K����e�� �,������x�������J��������I�7��������}j�����N�K.�$����]���
J4�m���!�b�����;m��Rg<�r)�u���g�a�4n�8�����/^,���/��0����[:t�`{�u�&�_�����gU�!�l�w��~�;�5k��j���O��}{��'K����"u��v�mg���_L��]v��#�v8�6y����\�?�6/��&�|�h�$���}���]�m��_��������	@��@��]��gp�]L������VR+���b�$��LN�;��������2�8L
0G[*6Q��d��������l�(��]G��!��z�����������<�$���G�
r���������[����n�����v�9}���6�Jv���]w�����]��|���r����6-z�z�������rd�O�%�]7�����w����v�_���m�b�`��A2a����Z!r��G���7)����Ts1s�TT4�/����>�|��\��$��� &nz���~�.�����+
�du����9��ej^�9Rvz@�X>_�Vzt���
;U���L����������qj��n���������_���������[I�.)Jv)��}���������}�?I|�RAfJv�?>Gz�3��=�������'���ri���%����~���6���g�i���g�| �;w�N�:Y�������;��/�8�O��*���pH��TT�!��ZY��@4	��?_6�l3Q�
���~0�D!r�@	 ��X5b��K��{2=��`C�~�9���}�H�}�,,����f�mJv9}����:�%�Z`�m��y@{f�nr���\������z(��&��j%C�>}l��
j�������3o|`���?O��K��+��R}�aeFv#%��\t���s������n��hV���i�b�������v�>r����eTM�J�L���cQ�!s=������)fL��|���� �����M7X���2�����;n:@������O?�ty����G��k����13�=�\"��x]�wI�������������d��{���M��$���/��?�7�N3D:�K	�'�xB���Z9��S��G�i��Q����g��j-��Cv�l�2gl%n.��r����s��Q5M��J��������S�������G�+�� �[67���\�~��y����U��/���6>��p����������<+_|������������6�o~��\��q���k��������������s���s��;����]����\����_L�f�[�:_�.qd�!'�9��?�t��>�����
^��S�.��"�����"J@��~�y���.����]nP�������B�v9��&!UM��t����jvfeU���'W���}a�*�eW��2r���y���R��0��Jv���2"d���6J;������3�����H}�FE��r���d������Nd���^.��}�%R�dW���|C��7�{�!2e���xj�����fJP�U���;�����.m{9-��vj{�N�3��^zwi/�T���zw�?�������L��lq�V)�U2�����2���;s����G�V�j�:([F9
0������7��<)5�'�����-q��dx�L"u��;��j�X�����M������;�����/������t�t��Z��j!��8���*&����/�0Wv5k�L����O�(�����q��q;Sv%�'���/��C���X��v�������u_�����{���[��Vt�����<��������e�z~�����V��]J�)����%�aE����reW��j;�u�m������ga����f��������.�|�Ac�����h��6��>�gM'=�������J����w�D����ur�F�U�DIs$�����@v�|�>BF���.B@��""�"��A���,O��9�+����a���b��W_�z���Z�~�$	�t���<�|f��������<iS9u������/��b�[��{�����eV�8-��k���S�7��>j��7;�����3fL�J$�c����+����>M����9g/��:���g���n�In��V���]����7�q[�����K�"EI�b���}Gf�����f�M��)#���*�g�}���b�?��l���X1����m-;8��p�����G����%��xm�^�Ay����j���r�}��s�����<_��eu0��������>q�D�'%4�*�E��Ga9�{�^�y�\+�m�}����+�{��B�������yw���z��r�R�����2��;N�����{��w�m�D��~�����6���?�al��d��5g�����oI�v)��������R�����+����}�+�;oo����1��H�~�v��r���F�>�O�8BN��<��JT7o������j9�����/xf�����6��[v������Tmg:d��b����v��.�L�v*��wGbf�w���+�|�W��.������:��[��jg�e��Y�<V}��;�6�9W������(���Xbk���XAI'���x�I
@v�!!�
�H������l
d�����K.��r��]��5��d�^�/�����6~f����_��O|���������k�fPmow����ZM����O?+L����w�e��o�Cn7����������
c�k%C��?ue���������k�[�'��>t������+���9s��/���uK�?�> {v������������5�\c����b�V<4�{�K�j~r��F�����c?��A$����m��s���������Rgz�o�M����1�B5^��Or���H��+��l+W������2��R2�����y�2y����t�^d�l������1~�n�,��~���t���yb\p���`�.%��j��>�k��(/>�V����dx����`Z��_�]/�\�|7�7�{�����z������1�J����Y�-��$������66����{�u���oM����:yc�<���i��g�<,����1�������M�2E�>�lSh���S��mx��ON��=/�6����q�'3g��
X�P�g�����#�[���mS�{5U���Z*u+�������~]S��z}���V�c5�Z:b���0�|��rC���x���!����@v�|�>BF`�������m�n�����
@���R�q"B����^�n����2E$�����:I��6���J�Z�J�{�9�4iR^ssk�F��|8�a���XN�h���y������L�3�����k��[�e���a�+���9$�b�n����]��v���������1ljk,���F5>���d��������E[��V������:�L���6�('��mse�����?�S��r|��k�����:S�8�-������w�������dW���^�Z�~�i���
��G�����YQ�e��?I���i���3���u�����P���������t�sfW����]d��K�n����g�_��/�,j[��v�_jnc������Kmc8g��2s����W��>�����������g�9�� �p���g��o��<{�n�r?�KS�MM}VW�{�,Jn�������z/��e7/C�7�W�pE7�����_~(�B����|W)&7@�
dW���+������n���Z�
�	�;VN<�D������h��m5�c�@ Z�]��'�@�8�-��2,%WQ�%��u%�[%T��n�>'mEk���Z����J]����xW?�8��[����S�*.�bL���WW�P�M�&�{�QG�I�����7g�����\v��.�rd�-��.���c��ek�x�X�g���j|���gvZ����JQ�3)A��9��5����L��r$����"B��]~�q2�#������*��s�v>_��]6��v��y�eW&�wW�����uV��)���d���V�9���M��=��R.[��@��+�s
��	�B�������o�f���Mm#���[�0]D����?�I;9��m�>��@v���!�
���\�Noh%���g�L��_�S������z��b�1,����]�����`����?[95�5��k�G�����3S�q��q��Rv��~�Jv���y�f����u��z���~��]k��Q�����R]��O�]W���]���������<�Z�e����]�W�:�0��ai�+���a���!v��
dW�
�8]dW�'��+��V���w������'���`�!���>_��������m#Ev�"�
 P$
dW��h�(H?D2S��=���
�jls����6F���0��zI�o�Oo���i)�d��~�lf���Kd�>|JF��^Z6/M����	??�4%��?��K����{&�^]����m*������e={�Z���|��d����D����Pb�
dW4�Xr����qc���]{���,_�&(���]g?0Q&?,���{m)[��w���s �
d��:
dW�.�
jdW��]/�/��&�Z�\�d�q4@"��|��3����[���������)����{��U��6���|9�+���<�~V]�"o(Kv9�!W���V>�7�+�������K���d��.�Fq$�d���N�=G�����#ed�q9����2e����� 
�A��E��t&��*�:�>@Ev� ��]�����)�U^���u�]�{�\}����ui+0�pf��.�dW���MX�`��������� }h@��m5� ��@vE���
�X�v�<���2i�$m�����u�6m����������W�7y�aR{��yyL�6M��+Gu�'9*a��O?I���K��k����?�G}$()>?n���O�K�.y5�cl'c|��7���?�\c�1���05V��=zH�V��p��z���K��]=�\��~�zY�b������_���z������r��]�~V�����~V��_��a���rs�~M�t�p
��~�Q>����y04 
�N��;r�|&����������]���"��-��������{��.�#d�r	�+�������g����d��dh�����*���\�a�_I�g�y&�?������C��Z[f���� }@�@�	 �b>
H1 ��
�����kt���+���^�.��O�����4��[��
E��y���� }@1#P����f������,s�-D�����N�|��]�� ��]AW���� �N9�9��3�_�~E
s�
��N#������v�]������]��f4�	<��#��������'��%B@�h=z�To����NM����K.\(��sN�cpC� ��U/���'��*���w ��&���]��Y�GAv�s�=��9d�3N��@9�]�������`�x����[o--[�4P2o�����&����[jkk������[o��8���:��!���/�/^$����	w�G��H�:�]w�q���7On��v
�&/	 ���K����]�W
�|
���t��u�	y�����������]!+����+�es/����SO=U=�P�j���K>����oo��-Z�Ql���r�%�C+Q�]g�q����[~���Q`����#2���d��csF�c3����OQ�?�| 3f�%�t���]>���t�M9��i�F�7o�s��V$
dW��h
���+��!���A� ������#��]v��eG��!P>
dW�C�CXd��	���N������+**�U�V��?`�y��7�s����?�AGMv���[o�%�o�{>�������L~�����G����gx3���.Y�D�g���3s"T"_�}]��9@���Jtn�����l?8w���v'�x�����9��U��&M�%�p����t

hM�m���Q)U����.u���0{�[cM�6M��+�&�1b3�j���#�=��I����Q����>?u�T���~^s&W���"���2'h���3��3�����2��J��p�^��i]_�;^�%L��,��.�v�H$��81C*�fK�;${����$Q��;�Yj�g�f��L8y�U�J}�
����\N�W�������o��j���;���-V3�n|7�%���g� P
dW9�"poXd�zP�x�bi���I]m���'�D�
z��r�b[!]���3@�����R�(��]�=�
�����L�'�>	�{��e�}�uk���9�����y����d�f-���.���m�F�i�\E5�\�8����
 �9
�d����:�P~��M�%��}����HgC,���g�C�"D��G�)��,7�����/���p\+�%)�����S$�%�R5.'-z\�j;_���h��}�]����d��{'8�V�	��?�N	���I�|nRx���2g��2s/�Dp���~/7�������gxA��$>'m�,�����^��d����o� �b>�"�v�m7�>}��j��w�2[��y��j�6g�s��Gt
������d������e��'�������?[�����e�&Q���W3�~��E���m9���>7�i�����/�w�����]e#�@@s�������5�����V�k�,��IY�xeJ�!fe�+��q���=�A���/�R�������4��[,�p�R_�e<O�OJY��wi�����T�S+�����3dRB�^p�Z�����\.P_���]��%�����?gm�wo^"��,$}C E�������h"��_�T~��I&m���V�[w�f�=�F�����Z�;����w�yg�p�
��0����\�����M�&cBviS���?�E~��������;��3��Q(��#F��-p������y��E���*7@!#�����[?������������tK-}�3��V\X��t�R��o~#���/5���3��VP�,�D2��u�2V8S���\�V��}�6��h��g�z���rV�i�>.,�Rq/>�v9f�������\.����)������6�����N��������y��rTA�,������f���������o�J��n�k��?��l�����gO_���`Jv�l�J��[_1s�������1��,O]vh����'y����M�����������<����������wl&�3W:��j���Yi��cN�jeJ�D�������z2����Z(�V��M�e�(
��5j�Q���>��y��^��b���X�������
���p)=� IDAT���l�>�'��,F�f&���Qq�eRe����s���������p�uR9#��.�����.]����k�vq�$����i#���1K.��b�dW��@w�q,eW	?_�]��S$��]1�Nd���VK���b��9f�L��]����q�<����{V�=�E (�5i�=��K��wh�Rv���<����,U�0�Z�f����[V�^m����.{�8ZFm�K�m�"����piQ�R***�|�)g�q�-@���=��������w�}W&M��.�,��6H�2Qr; ��]V�P�l��z��$�.�&��j�V.x�7]�����vn�'1����d�q�9��N��]Z�U]�UI�:�.	x������nIe�K�v�Ov�������/�B ��+�"H����O���#����Ux�����E��cN3T���]
�k@�����'�+l&=;4l�G�����On�� r���\~���YC<q�]N�1��fq����A��L�t-��Ui�����Y�i��tD^����Xm���b=��#��u�]'{��g���RceW����x�.+1\�
mch��%�(-V�h%�
�qw;���gdW�J=g���]���=%sktcJ�J`������'�=�%��]&��������A�d�@'m�����K������z�
�
dW�g����7���k��6�l�$��d�������g�6�!2~��
�������e�M7��ly����sN��k�e>^����"#�m+j�S���f�y��s8����C=$7�t��|,X`�9���O�����E�z�C9D������v�o�;�s����U'����&�\�|������^z��t�]��O=�TC����}��n��
w���';�������*tF�}Y�oa�%W(d�&�&�J�7>��Y|��.kk�M�&[~����,���Ur�
��b��>+meW�?_�]E���(���$l������s;����
aP����������e��r�e�5	J�����U��l����&$��;�3�����?\��c9�����i��O�����^�=�������D	���J7�s��l���E3����9�}��'�T�3�\�����_~X��tj���_�\���m��Pj�Q�]o���|��w��V[��D���N�*;�������9qe��U�6���g��%��5���n������%w%�W�
����C�vn�f4���]�����7�x�4o�<��������� �-�]..�A�X��.s�b�\�'���e�3�G���3M������XuaXh�����])aS)������`N�H���m S�9c�do��j��M���}����.��p��2���g9?_�]�����]1�E����r�������$�~\�bd��9{�I���s��}����U�+�����]�.��������eh�-<����C#���
��U��r|���]N��*������]w�r�Ly��n��
=���g����K�����/J���s�y��������v������C������YF�U��Y���4o�������eOK��Rb���N�i��M��}j���\����� �ICv�T`��#�5�3�9��_Yzs����^�������R/:��.�t\��F�U�S�^���~�.�,��K:�RY5��=\��H����DB��p"����g�]���������B��`��Z��~:�����d���Jz�@c������eWgvy)���?W��C���U���It��LS��>�l������cG�m'�J�\��0
���xNV���7jHo9t���(��]~���q��z��w��.���K�.y�K���{����S��tC��`5���~�1�������~!�~8'�V��$�~jE�����	
�D �k?���Zy��t�K���n]-�c��(���X��}�"�LX'�ey&Vz��MV�Y<�:������K��R����_V��;�����J���s��?��+�K�����r�G+�A���+��h�%�2,��kP�.��=:�M�O���t5GX��r�����_�7>~V��<��Y���O�����c�g�����Q[��-����R+;���Z_�.4X�dW����OW�5��m������������Q�ee�]-[���y��'d�������Q����~%�?^iF��6C�����]����s3� eW"��u�����o�dJJv������i�VN}��8r�Bvy���!
M�%�������t�<@U�����<Z��4��(~9�N�Q��6���y��V��H�BI�$���+|��^�h7j��G����_���J)k���5��[���5�/����?���r���9k*������>����������f���pI� ���������
�
dW�gBQ�+����q2}�v��Mv�z�$�n��y%���>�r�(s*���J����\p�s��+��T�����Tlc����2d����j��
b��gH��
u�(�����kA�Lw�5����;�73�v����m��GMv���[�*��K�Kv������E�"���F���8]A����g���+����I�Jv�z�0�����i~���e���$���
"��k�4;v����:^����1Zb
����+��?f�K�N?�u�7�8�]A�g�8@v�U��o?8��!'���I���
��d)w��X����!d���]G��3�����]�3���>�|�=�W�<y5���k��3��8�����r���]���C=T����N;�4�g�}�>��{����.�
EMv�U����z��if��W/9��s������[������k�[����}�4��jX_�����g�������w����m��y�Q�]��v������er���.�e��k~0����U�.�>��x�
������/ 
��]NIy��������
%�]W�E���0�=�����].�;�	�������(����>�N��k���HCjI��'�3/��Jv�z��y�����2dH��Z�|��\��d9{�;|}s�gv9�]�v����r�A����{w_�.4����"�+�/���M��Q�]���G}��c���E=������-����tl����+�N?�t����rb6l�������
�yzKF��Z5��2��=���K�]/�a_x����F
��q>Q�]�q��I����T��3�8#'��d��g�%���_�����t��"W�3�ny�uY��y��O�O�R�a����voz{����G�:4��p�5��h9g��s��M���'_��#���?Y�
=;I���U�C�w�;������;d�{��.�X��D�|��]��@��]�W�>>d��n� ���:�'��*������{V;��A�,��]���J�e�YR}��\'������Jv=��Sr�����s�=�G����2{(VvM�2E���/J�d_�]���������.���e�W�.�G=d�����<�z+s�Cv�$gT��1���od�C��|��;�(���l/��=���e����{��|t�]��^"���������P7r��3���_%W�����l)���mc5��c�?���|g��i��g�\�'w��C�������h��g��'�+�Y����z���~����������r�%=A N�]�W�|
t���{���Cv!��f	����C�|��BJ��A���$������8����>)����{�M�.c�����+q.x%�t>���]if'M�J�o�������d���rh�g��m�Vv���2a����%NOn�4�y���VdC�u�e�_p�5k�H�d�����V<d'6���&���n<6�Vw�u�|���r�	'x2W����]������zf���l�]���'�cEz����Y����zH�3��,�/^,��{�\t�E�Ns���e����c���g��1��C�$��.�r#����'��
~V ����� �t��}|�.d��,Av��u�O�U����`B��%$w�T�UY�~����]�}�,L
���J������f�Ev��3��o�Q�wShd�Zj�\rs�i{K��-�|��[��c�E�W�������v���v�Wven%�|
���"+�,�����(��}�Gv�l������=��w1@�vl8�*�����'���/��XU�����J7�Ose���]�D�Z�u�����A��Lr�u��lo����6���- �|���g�+��
�K�
��g�����������E�Y�	���������t!��*��NZ:���}5	�jJ���N�S(U���#������ri��L���(��TUW�����C�C�@>Y����*c�u+�kc�7o�:�In������2)��n�U�8C#��Mnc��&�"5��g���9��Mv]y�9e�����6�+�~*w�r����E���m|��:���9���r��r��{�;�k�#�\CIG�
dW��Fv_�#@v�^!���,����B@v1 �=
dW!�N�U�F�N�rr�C�eyW��]�Uf�����}��^|�EQ_?�����Z�j8��q�/W��_\�������_����5��w�|��W��_~0�������_�f�
���Ur^mj�<u���l1�S���\r��=Z���U������������,w������GJ�6-|����*��Zfk5�{������o���ui-7�rS���m��������3��!����i��i�6��C�y]V�]o3vx9k���C�3�n��vQs.��.���]'�_����C:��
�?wl�\&��ga�s�������e+���k�A6nxW��)�Y�q�v�s���\�<�z�����r���$CN����Y��E�7S+>E����l=(�s����6�����_�i.��>i���l����vsM�����+�k�6�[�aZ�w�A�-M�8�Q���]�~qy2���_�������u'�������S��Vu�3�nX���������}��RSSSl(�_{��������.'?G?Y��yc�g����)�{���{��o��6oC��k�#'�,H|%�j�,��n�M��i{n�G���X�~��n��������"��
~ ����� �t��}|�.{Fqo���� ? �
Q��V������lch)�Rgz%�xg}�����Z��>��CQ_�<���a�
�����Nv�9�|��}G���~�����]>��s�>}�s8g��>�����VI���zs���������e�����y�����;����[T>M=�v�����/-[�l�a��~[�:�����K��N�
�K�c{�n�����G���K��������[����������.k|���ke�v�`8�k����C����~���/���x}��
��ic
�}����/������=� Z����g���ke�9
���l&G�/���{Y�U���`���r�_�?�oXh�u��;��a=����N>���[r�c	��W/�W��Imiju����r�
7������_�� mZt��68�56��-��={6�Y���>'��}j�9�wG�w���W�w�]v�E���x��g$s9X�tqo[
�Y���l�s����������z�\z�6c}��Dm�w�-�������Y����r��G6y�b��'���>�b��?�Q����)G�Rx���g�n~���9
��vA�r������^0�����_2�w���o;P�x�{s����y����������S�.���k����mTzFv����������]^�$�;�0 w�TR�s�fKeZ,5`II���:I�������*���s����?��l������R}�R���g���W|�Z�����c�����l����/��2'!��Fm��D����Z��.�}���|]�3��y�i���l�U�Y;���w��r������6��>��TVV�FmT�>a������=��SZ�(����AW�����<�J�<;i�\,���fC�@��W^��'��<�+���_�*�PX����.�3�J��/�h�����0��S�*�FnX�H�4Ws�C��*�B�����|�|����K����w�gv��7�d�&E��g�%���\m��t��P}����M��4��Jocx�������Bmcx�1��f�m�S��O>Yv�m��&��3�>��cY�x����^�y���e�3_wk����I�2��U�Z�����^��a����Z��mU9l|�
c/b,�O���}����b��`e�s��A4
��y����r)�M�]1���
dWA��-��2$XRx�%��u%-YR@U��&�s��Q`��1��K����t�]�K��-�Q�F�2��Av�}f��i��n�:c��Z��������:��C�_JP�}���8��e/������??�4#G��
�������������\���T��y���d�MK�\Rq��	�U,�B&
Vv?�]��@��]�W�>>d�=���@v�}���]MQ6�\�6Ww�K*c+��"�������>�v}7�f�Ea1�J���]~L�Bc ��]~�?�Wv�{���]��]N�������]��|��Z���t�m��%�^��Vv]|��2�|���Rv9��f�.O��) 2�����
��G����B��!�����+�3��� ������Rf�����,e�jls����6F�
�"Vg�����Tt�m��D��.�1�{��:+��^����{r"�>�j��q��f���?F��=w���G���1����)�����W� ����m�[A�Dv9���!����t[d�{,�	/
dW��Cv_�#@v�^!���]������@�~@v�AY�1�]�.?�'�+�����R�XNd��������j���m�����S9�;9�����d����a�v�P����A����~\�}d�1�wg����
����8p�q6S�k�����A���e���@ ��/2�+��
�K�
�����g��������������;�H]]�L�4�`�+�Z-����z�1�d�����j��e���_���n[0�.�}���|]��]�-�v���&�lR0��{n����R��k���k�R��<���RYY)}��)������/�c�>�_WYv����Y�Fz��-�W�$_%�&L� -Z$}�J>]�����q����+W����*�������._���,3f��]���,���������Bv=��S2b�����+�-��g����.��5s%� Wv������e�]o�����O�e���&�f��[)�
�t'K�.����g�=�d�����|f�����o�{�����
dW�uDv_�#@v�^!���]������@�~@v�AY�1>��SQQ'N�X0�0�.'���]�!j����M�6N��M��$�����$������m�A�.��	Rv��K���Rg�v���X��
@�)
d�SR��Cvy�6*=#��_IdW�k�u�.�	�?D�]1�q�]������|���y��(�vguA���+�#�\�H'p�����V�����]����/����j�SN9��q�Z �bVp��@	 ��/:�+��
�K�
�����g������������G��q9-I j�������?��i�
r�A���d@�@v�sCvf����?���M�|��]��@��]�W�>>d�=���@v�}���]~P�xd����ihQ�]1-#iC�W�.{��.d��,� U���+��
��G����B��!�����+�3��� ������c �4.NLCCv����
�2 ���!��]����@T	 ���,�+��
�K�
�����g����������������81

����6� ������Bv��Z@Q%��
�����k�{�.�+d���Q�[ ��>���.?(k<�K���44dWLO�(�����e?Kh

D��+��"����� �t��}|�.{Fqo���� ? �����~����J���Dd�t�K�H��<�B3s1VKm��lw������[�k��
�2W���^���@����M��[BfTV��(H]�ez]Bj�����!�U��L�Q��O��D�����������+/��Z�����l(G��A����\*���v�����r�=�I�b�D1m�YP'S�8����+�7P��X�|?�����S'8p`1)��9
dW��|
t���{���Cv�3�{dW�g�{L�}7 IDATE`��f��.�(��_Oe��P�Z��������8���^I�����p
��P��������+�+�Aphe����|��$)�+�H"K��ZH��U���]2�
<]?�����]�����77����������|����f�����-��H����r�=�I�b&C	m�.�z�]
�UB��dW���|
t���{���Cv�3�{dW�g��A��e���Tv%�U.�1V9SC-���eM?�����t�Is��
E�|��]�Z�����=[BWI?�����2�&?�����Gy�k����uK�X5�f����	�?7���Gr����<�U`�9��V��7o.:t��[���
N�x�c�e���'d�����!Q�����
��G����B��!�����+�3��� ������cx*�����*PD5.~hy+���\�e�5�*�f���������z8?gr8��sD�x�HH�4-��)d�m��Zx|��}
	����7z��'�eW�������
N�xQ
�����5.���]^���@�	 ���1�+��
�K�
�����g�������������Dv�Z����o�2�8hl�L3����z�UT��4�j
'�e��x���dWv=$u�RXe���j��s���
�v��%5��v�uR9#gv����/���]S������
�V��9VPv�����B's�I'?��m���r�������P�]��dW�5�=d�����e�(�-�]q�
��
d��5���r#��`�{�>BtL R���[/TJ�]�V6���������������wB|>�y��H��i�9�+�����^z�e>	B�5��6��y��w�YR���9����^�s�=�I/b�Vv��]
����OD��+�#����� �t��}|�.{Fqo���� ? �������R�c%$J�K���Vx�]��+�!iheW!��oSfyA��|r��5���oJ<��������*y����c���<22ye�<d��)�I'"�I/��Nv��]
����OD��+�#����� �t��}|�.{Fqo���� ? ����������v%D��w���yMJ�]�OH����z���6r�+�b%]�dq$�2�+��d��(�1�3����_��R%�]�:<9���L��q%���L�W�����Dd9i�Eno�����L����{��
{ujr(�X=�����b�'�O�|��]��@��]�W�>>d�=���@v�}���]~P�xdW��I?������~�m��(Ev�>aMreJSP������_��r(��+��4PH	�J��O�X���J�eo1�
*\�i,���f���O�G<v�
�.9���g��JBq����_�7����]~U�q -������
��G����B��!�����+�3��� ������c ��(N�*E��K�����Z���z��|�QXu��U����C���Z�o�0=�/�k�y�*�b�� �J"�V&��2k%a��V+(�
IH�����[7C���N�/N����(c����e_Z@��]��
dW�5�=����N���d�-��=T�+@����#���#��(���|���
���|�U2]�5�����j��g�~���^vY�qe]/��T�X<��:'*4���k�SSl�vfW^>�/�ma��-���1��,'m��]J���z�]
�UJ��@v?�]��� �5
d�����?�+�5$�	 �����z)�R�_���"�gD�t���a~����/����c�U5��mx�Ek����k�}��k��]�:~����z�m���Mc1��������yP��4���$'m��@�#��Z�0��n�,����K��@
dW��Bv_"����]^�������'����F�F����4p:�,
�dWd	� �����]�b�Vv]|��2��pN��@vy��
 I������
�D
�	 ��&���]��!�O���<���)^:/���h���@v�|�(}dW��M�p���E�%v��*�A D�]!*V@�"����"���U���Ev�|h�>�K��4'5��t�Ry�����O��<��M��7q��@4 ���#�+�
�&����p��Gv���d�?
d��5�4Bd��x�����qbN j�+��$�& ���@)�,�T��?Zi���mK���C��>�L��m+;v,��� �<G���+�h�K�` �"P�rR@v�C�{� ����*}B ��]��/�5@v1 �R�]v���n� �t��@�}�.��F�GdW�*J>:@v�XcBv���@v9�D#@ �@}}�|�����W/�@ ��]�./�A�3�.��:�x��u�f������{h
���+\�
"ZdW�3n�]q�x�|�]1������(�
@Z@viQ��@� �BW2�BH����2��g�K��X��!idW�'���#�4,
!A���]Z��  :������!�@v��h>����8����+�eGv���Z�����<
@
@v��!b����!��@v��T���
=���+F��J��]1������(�
@Z@viQ��@� �BW2�BH����2��g�,0sEv�����"�b>
4L��E���>����S��2u\U�(��_/w�q�y��fBH� 
w	 ���Io�
dW\*M��@��]A�����p��(�M����=��l�t
@�|!���3�@ r�]�+)	A@viX�BBviV��$
dW$��<)d�sV�� 
@A@vI��!^������!��@v��VAE��
�<����+N�����	@�� 
���+4�"PhE��U9�(
dWD�bZ�.a�
@v�|j �b>
H� ��@v��T

� ��*�@%���ha]L��"L����9`E���� 
@� ��
G���@v�V���H�������]��
+�����@v�|�> 
@�!��
M�Z@viU��"J�������E�t��]1����O�� 
@ 4�]�)�B@+�.��A0�@D	 �"ZX�Bv��� ��bX@v1/ 
@�@8 ��Q'���n�]�U�x �(@vE������r�'�A��+�b>/�]1��
@�@h �BS*��V�]Z��` ��@vE��.���r&]A�
dW���+���!
@

dWhJE����K�r Q�������].��+ ��V�]�@� ��p��(!�
d�n!@ ���(��y��6��(�GN.@v��. `C��]1�"���O�� 
@ 4�]�)�B@+�.��A0� S�����}%����~�!���	A� 
+�.� P

dW)��� �.
d��<�
V�]1����O�� 
@ 4�]�)�B@+�.��A0� S�����}%����~�!���	A� 
+�.� P

dW)��� �.
d��<�
V�]1����O�� 
@ 4�]�)�B@+�.��A0� S�����}%����~�!���	A� 
+�.� P

dW)��� �.
d��<�
V�]1����O�� 
@ 4�]�)�B@+�.��A0� S�����}%����~�!���	A� 
+�.� P

dW)��� �.
d��<�
V�]1����O�� 
@ 4�]�)�B@+�.��A0� S�����='�`�sd������w}�� 
d ���@)�]�P�@����]���7X@v�|^ �b>
H� ��@v��T

� ��*�@�@L	 �bZx�����W��
����&D
@�� ���@)�]�P�@����]���7X@v�|^ �b>
H� ��@v��T

� ��*�@�@L	 �bZx�����W��
����&D
@�� ���@)�]�P�@����]���7X@v�|^ �b>
H� ��@v��T

� ��*�@�@L	 �bZx�����W��
����&D
@�� ���@)�]�P�@����]���7X@v�|^ �b>
H� ��@v��T

� ��*�@�@L	 �bZx�����W��
����&D
@�� ���@)�]�P�@����]���7X@v�|^ �b>
H� ��@v��T

� ��*�@�@L	 �bZx�����W��
����&D
@�� ���@)�]�P�@����]���7X@v�|^ �b>
H� ��@v��T

� ��*�@�@L	 �bZx�����W��
����&D
@�� ���@)�]�P�@����]���7X@v�|^ �b>
H� ��@v��T

� ��*�@�@L	 �bZx�����W��
����&D
@�� ���@)�]�P�@����]���7X@v�|^ �b>
H� ��@v��T

� ��*�@�@L	 �bZx�����W��
����&D
@�� ���@)�]�P�@����]���7X@v�|^ �b>
H� ��@v��T

� ��*�@�@L	 �bZx�����W��
����&D
@�� ���@)�]�P�@����]���7X@v�|^ �b>
H� ��@v��T

� ��*�@�@L	 �bZx�����W��
����&D
@�� ���@)�]�P�@����]���7d,X��������@v�|�> 
@�!��
M�Z@viU�� ��@v�����+
d������_M�� 
X@v1/ �R �J��=� 
w	 ���Io�"�����@v�|�> 
@�!��
M�Z@viU�� ��@v�����+
d������_M�� 
X@v1/ �R �J��=� 
w	 ���Io�"�����@v�|�> 
@�!��
M�Z@viU�� ��@v�����+
d������_M�� 
X@v1/ �R �J��=� 
w	 ���Io�"�����@v�|�> 
@�!��
M�Z@viU�� ��@v�����+
d������_M�� 
X@v1/ �R �J��=� 
w	 ���Io�"�����@v�|�> 
@�!��
M�Z@viU�� ��@v�����+
d������_M�� 
X@v1/ �R �J��=� 
w	 ���Io�"�����@v�|�> 
@�!��
M�Z@viU�� ��@v�����+
d������_M�� 
X@v1/ �R �J��=� 
w	 ���Io�"�����@v�|�> 
@�!��
M�Z@viU�� ��@v�����+
d������_M�� 
X@v1/ �R �J��=� 
w	 ���Io�"�����@v�|�> 
@�!��
M�Z@viU�� ��@v�����+
d������_M�� 
X@v1/ �R �J��=� 
w	 ���Io�"�����@v�|�> 
@�!��
M�Z@viU�� ��@v�����+
d������_M�� 
X@v1/ �R �J��=� 
w	 ���Io�"�����@v�|�> 
@�!��
M�Z@viU�� ��@v�����+
d������_M�� 
X@v1/ �R �J��=� 
w	 ���Io�"k�5gr�L�k��Zj�����Ks&KEv����.Q#�vs��}6m3*�j���H��J���G�aL�bFv���!
@���]z��( 6���U�x!
@ ��]Q�*9�@`��f�.����p*x�eTum���%dFe�����>�6�RY��nu	�I�5Cj5��Q�b'��Xb�� 
@�@v��Q!v���W��!
@ 
�]Q�"9�N ��+-�*��]��i�T��q�����MrmYEre���L���?�����u�P6���U4n� 
@
@v�!CA��
��.��Q�}{���+�� !
@ ���]|���!�� ���]�Vr�U�IL/ ���w�-�YV���hRvf�\9�R���@v�~�1 
@��+0��+�����H�TW���V[�����rs������������K�	L\� '��.��i���C��]s*�E�����X����y^����LOo#���fU������������1,s��L.�.���A� ��	 �.��G �����5�.��;�Mc��6V�;��Av�@v�7u���G�u�����M"2�%c��ZA57g���?F������*tn���jR��HK��< L�fgT\F���,g�Bd��{�� 
@@+�.��A0���]n��a�e�[}����K��J8� K���,�|���"i1�]��C�m����\�]�'q����t�|��� {��gd���yI���KEE�� �(h������OQJ�\ 
��[n)�{�� ����C���-������'�r�ov�@v�v� 
O�w���w��
��D�'���.s����m
-Igm5�?|�>L$%��{-���%����������/e��u�+����?�9�����5k�g�������\�����C2BC�$��v�p��������n���Lc� ��Nv��{P���Y���*��Y���-��R�K
]e���rK����I��-���u�>��j�����@� 
@!#f���n�-����*�r����_/�Z�
YU	�&�/�1 nj���y��eK�D6�pC����V`�8��l� &�]��^	&��@�l��j{��UVF����K���J��rp��6��3���E]���/!�b�N%M@� 
�����:Jz���6�.���b�
Q�5nu����
 ^��	%�� ��P���q=z������&�� ����wV���+�29g\e������Ls��\��/���gK��e�/��}��n(���N�1ts�� 
@� 
���`vv��i 
@ ������+��)�47������%]9�F�R�l�#���f5�]F�)�U��T��r�/l�4#�R3�X�V��W�]B� 
@����C�v�0�q�S��6������s�
 
@Q#����U�|J%s�U*6�� 
@� 
]X?�IF�d7
m��C�J 
@�	�=�9
�
d3
� 
@�BG�x���MGV
��q8�M��<BW� 
�����\}r/D���� 
@� 
@� 
@-
dWhKG�� 
@� 
@� 
@�.� 
@� 
@� 
@�@h	 �B[:� 
@� 
@� 
@@v1 
@� 
@� 
@�BK���8 
@� 
@� 
@���9
@� 
@� 
@� Z������!
@��61IDAT� 
@� 
@�@<	,X��L��9@�� 
@� 
@� 
@ �]�(#I@� 
@� 
@� �x@v���d

@� 
@� 
@�"A��2� 
@� 
@� 
@�'
dW<�N�� 
@� 
@� 
@ �]�(#I@� 
@� 
@� �x@v���d

@� 
@� 
@�"A��2� 
@� 
@� 
@�'
dW<�N�� 
@� 
@� 
@ �]�(#I@� 
@� 
@� �x@v���d

@� 
@� 
@�"A��2� 
@� 
@� 
@�'
dW<�N�� 
@� 
@� 
@ �]�(#I@� 
@� 
@� �x@v���d

@� 
@� 
@�"A��2� 
@� 
@� 
@�'
dW<�N�� 
@� 
@� 
@ �]�(#I@� 
@� 
@� �x@v���d

@� 
@� 
@�"A��2� 
@� 
@� 
@�'
dW<�N�� 
@� 
@� 
@ �,X`���
m	�@�����)"��2gr)}�{)cr 
@� 
@� �\�.f 
�H�U"8n� 
@� 
@�\$��r&]A�
dW��M�� 
@�@i���S���5wA��D��j+ 
W	d��)����rF��^���V�3{&fHe�lix�VdJ�6�	�Q�uo�������R5�2�cbr�t�s&W����9�jzt
@� 
@ �]�(#I@����]���s@:��]se�L�KHMe2nCn%�N���%�R�*#����2K�%%Y������^�����3#b� 
@� 4
dW�`|@���K�! 
������:I�K]Y�Wf������^�j���������Q��3w�����cy�"�B� 
@��j^� ��@vE��$
@�
�p%�Uf��l���|0������Y��'�yY]�[!����`
�#R @� 
@�&���./�A���]Z��  
A�m��X����:�K���Y]AT�1!
@� � ��F���E��z�- �,�������Nlc���<�k���*��}�u� 
@� Y����]5";H�<#���-C��@����j;7k�AuWjGB��a"y6WR`�t�K�H�����S���te�2s�D�y 
@����w79MEa�L`'�F�02��!��+$8rHnd
�Y�YC���*�`l�J�wF�^�����\�r!@�� }�{��#�=Uc���
b(�b�k:�!��
WUH]T�C�������'�������*�����~����n�Uc7]����)�O�R� @�
*�������S5�nc @���]#�uj @�
 @����(�<U���b~P@�5 �� @�
 @�
�_����{6O���� @�
e�-A�
 @�
 @�
 ����+��,�
 @�
 @�
 @@�e @�
 @�
 @�
d+���6:'@�
 @�
 @�
Pv� @�
 @�
 @�
�
(�����	 @�
 @�
 @�
�]�
 @�
 @�
 @�@���l��p @�
 @�
 @�@��F�����2���	 @�
 @�
 @�
!�]!b4
 @�
 @�
 @�L
eW����
 @�
 @�
 B@�"FC @�
 @�
 @�
�Pv����	 @�
 @�
 @�
!�]!b4
 @�
 @�
 @�L
eW����
 @�
 @�
 B@�"FC @�
 @�
 @�
�Pv����	 @�
 @�
 @�
!�]!b4
 @�
 @�
 @�L
eW����
 @�
 @�
 B@�"FC @�
 @�
 @�
�Pv����	 @�
 @�
 @�
!�]!b4
 @�
 @�
 @�L
eW����
 @�
 @�
 B@�"FC @�
 A`z�Y�u�N�������F5
d 05�4����u�����K�h��"p�uI�%es @�
 ��@��&���K���7f�~�xrr�VW_���o��i�C`a�U���������v+��,+����*	 B`v�y����&&&{�M�wvBL���F#���d�RK$@����Cy�*'9�!��*s�yZ_�66>����������j��tt�=���
��������eW��J��/�]��l�#077�����e����!c��f�!�|o����p=Gu69�Jv����p=Gu�s���j6�iyY�5���� �+������{����v����i @��
Te����49���]?�� ����IEND�B`�

PK�-^W]�r6��benchdata/index_outputs.log+O�,��KWH�/R(N-*K-R(�W(.I,*�����T.�X45���'�5H!�����K� =��(�<�(W�K	p)@����9���BQ~�&��r�Vg��m-��b}~A
�z���d������GC�N
ez8y4�ANPK.^W���=c;benchdata/pgbench_logs_14_0001_sample_data_100k_1.log.11171U���0��Sh@���/�O���.����q �>c��BC^�z�\���>������nP�=�PKA^W��:B<c;benchdata/pgbench_logs_14_0001_sample_data_100k_2.log.11175M��
�0�=W�8�?�fj5�$m�B}��5F1���xee��*4�!o�c�A�Z�PKQ^W+��;c;benchdata/pgbench_logs_14_0001_sample_data_100k_3.log.11179M��
 ��+8
�������![Ab���]�!�"�{��r��B�;�o������&5PKd^W�e�\<c;benchdata/pgbench_logs_14_0001_sample_data_100k_4.log.11183M��
�0�=W��`����l�,���RQ�kG��Dwo��j�P�^1�����'H2��PKu^W���=a;benchdata/pgbench_logs_14_0001_sample_data_100k_5.log.11187M��1��U�!<���������v�D���*X[����&��Dsz���<����\PK�^Wwc�=c;benchdata/pgbench_logs_14_0001_sample_data_100k_6.log.11191M��AB�|��u��;/���"�I�@D�i�c��Ch�6�$����?D��
6�5s�PK�^W����<b;benchdata/pgbench_logs_14_0001_sample_data_100k_7.log.11195M��0�>Sxl�����2�N��:�0����#P���6$���B���j��6a����e�>PKj^WPP^Af9benchdata/pgbench_logs_14_0001_sample_data_1m_1.log.11215M��
�@��U�QO��1_f����nz����n���'�`�%W~By`M���+���qfq�PK� ^W�?��Bf9benchdata/pgbench_logs_14_0001_sample_data_1m_2.log.11219M��
�@B���`��������P|= ���<��+���a��eF�O8$��������	��;K�PK�!^W�A��>f9benchdata/pgbench_logs_14_0001_sample_data_1m_3.log.11223E�10��*"����X�����`�\E��
y���yz/E��d����;�7K�e`��yPKW"^W����>e9benchdata/pgbench_logs_14_0001_sample_data_1m_4.log.11244M��
�0��Sh�`���T��gp8��`�����#(��huD��v���7�<l�_X&H/�<PK##^W3���@f9benchdata/pgbench_logs_14_0001_sample_data_1m_5.log.11248E��1��U��#����9�YAW������a��{~E�k*�`7vzc���H��K$U��PK�#^WS
s�>f9benchdata/pgbench_logs_14_0001_sample_data_1m_6.log.11252E��
0��>Sx^�/RE��(�����r����R�G`+����Mg�?������
�PK�$^W����Bf9benchdata/pgbench_logs_14_0001_sample_data_1m_7.log.11273E��
�0��Sp��)i���4I�8<9g+���������E��N��bv�$����#1?QtB���PK�$^WdXQI<c;benchdata/pgbench_logs_14_0002_sample_data_100k_1.log.11295M��
 ��)<�C�N�_��������b�u)M_������|����NV
�
�������zPK�$^W$@�=c;benchdata/pgbench_logs_14_0002_sample_data_100k_2.log.11299M��!��)<�������N� �L�!O{�H��hF��a�2.���$�
a�B��
PK�$^W��<b;benchdata/pgbench_logs_14_0002_sample_data_100k_3.log.11303M�� ��U�B��������58�(���
ys;���sZ������I�@
y��PK�$^W���o<c;benchdata/pgbench_logs_14_0002_sample_data_100k_4.log.11307M���0��Sh����/�����'A�l&������:�E��}��v�o�(��0�R[ZPK
%^W��=c;benchdata/pgbench_logs_14_0002_sample_data_100k_5.log.11311M���P��)2B~ �/&V��;"�L�ADy*;<���-��X��S���?����}=PK%^W�h?c;benchdata/pgbench_logs_14_0002_sample_data_100k_6.log.11315M��!��*T�,l�����;G�V3
"��qI�v�j�@���������8Q��M�w��PK+%^W�/��<c;benchdata/pgbench_logs_14_0002_sample_data_100k_7.log.11319M��
 ��)2����bjggp�eeQ08G�z��2�>��}���\����;�R�PK�%^W�� >e9benchdata/pgbench_logs_14_0002_sample_data_1m_1.log.11339E���0�>S0 K��/��r��� .�
Bs�T���|C�����m�+��������*3|^PK�&^WV�Af9benchdata/pgbench_logs_14_0002_sample_data_1m_2.log.11343M��
1��U�J�����):8[`�0�;�S�r:�*k�!|��)D��l�V����U�������PKp'^W�j^=f9benchdata/pgbench_logs_14_0002_sample_data_1m_3.log.11364E���0��Sh>J���s
�X����B1;���d���f1zC����.rZ;��i�PK�(^W�5�?f9benchdata/pgbench_logs_14_0002_sample_data_1m_4.log.11368M��
�0��W�����k�V�A�b�y�gr�K�!��)�oX	;����!2��}��V��PKp)^W0���>e9benchdata/pgbench_logs_14_0002_sample_data_1m_5.log.11372E��
�0��Sp��_,$Wa0S]a����B���7lv��M�(g���N��(���<PK2*^W#�|>f9benchdata/pgbench_logs_14_0002_sample_data_1m_6.log.11393E��
�0��S0�h���T��8B�NjJ
��g�KD����;�g7��Mx�����!w�72s�PK�*^W��|>f9benchdata/pgbench_logs_14_0002_sample_data_1m_7.log.11397E�� ��*T�������,!Hc�b�P�.�lG���E�b��5���������U�PK�*^W���R<`;benchdata/pgbench_logs_14_0007_sample_data_100k_1.log.11419M���0�\U����cVf��s"
�Ni�
w��18*&y��.��J�u�D�>�0�=PK+^W=��9_;benchdata/pgbench_logs_14_0007_sample_data_100k_2.log.11423M��
!��)2Ie�������Q�t�{N{�5��mF�=�L����T>�	O�b}PK
+^W���9:`;benchdata/pgbench_logs_14_0007_sample_data_100k_3.log.11427M��
�0��W����k�hU����\���u/���/����<��t�t��,+��b�a~?PK+^Wm]�9`;benchdata/pgbench_logs_14_0007_sample_data_100k_4.log.11431M��
 0���q�/BH��P��x��gFj��1�����Vt�_��\PK+^WPe�9`;benchdata/pgbench_logs_14_0007_sample_data_100k_5.log.11435M�9
 ���4}���[�@$K����S�b;Sy�^��d��{�����u����PK$+^WR�D�:`;benchdata/pgbench_logs_14_0007_sample_data_100k_6.log.11439M��
�0��W��P���O�
Y�\V;;��������|���\{? Vf���xPK,+^W�
*:`;benchdata/pgbench_logs_14_0007_sample_data_100k_7.log.11443M���0��Sp�z��bq:�8�T[��������8�l\��#+���=:�O�nf�PK�+^W�Ea�?c9benchdata/pgbench_logs_14_0007_sample_data_1m_1.log.11463E��
�0�=W����?�ti7
"�.�����=FV��"�H�|!�"�G~�F9m�������PK�+^W�N�%=c9benchdata/pgbench_logs_14_0007_sample_data_1m_2.log.11484E��
 ��+z(��c��e����%�ap�(�{P+E!�T2`,*��_��+��}�}.PKV,^W#�V'>b9benchdata/pgbench_logs_14_0007_sample_data_1m_3.log.11488M��!��)<��'����=�N�PGC�@�g��u���ZD�@u��d=7$���'L�W��PK�,^W���=c9benchdata/pgbench_logs_14_0007_sample_data_1m_4.log.11492M���0��Sh�@��K����@Bs��HyU�ePe�.�Xq��Fur�������)���<PK -^Wn(��<b9benchdata/pgbench_logs_14_0007_sample_data_1m_5.log.11496M��
!��)2B4`�������
��!���v��8#/� ��Y��)���.�����;u�>PK�-^W���=c9benchdata/pgbench_logs_14_0007_sample_data_1m_6.log.11500M��
�0�=W�l���k�V��{�d!@��b�h��O@p���_��%/��D�4�/0j�!�PK�-^WRy��=c9benchdata/pgbench_logs_14_0007_sample_data_1m_7.log.11504M��
�0��S0�����%]r�Bo�!��$Z��C��:�Wp��oH���Y_�$�y{�PKk^W/��>c=benchdata/pgbench_logs_14_master_sample_data_100k_1.log.10827M��
 B��S0B������7��B ��*���nEW�}��D����@{j�9@3�\~�
�^PK�^W
��=c=benchdata/pgbench_logs_14_master_sample_data_100k_2.log.11028M���0��Sp���_,�4	j��%�U{��x�����������!�PC��	;���PK�^W�96�;c=benchdata/pgbench_logs_14_master_sample_data_100k_3.log.11032M��1�>Sx�y�_��.�E"}�� ���v����J�'TA�c�68�y�g�{��PK�^W���k=c=benchdata/pgbench_logs_14_master_sample_data_100k_4.log.11036M��0��UP�~����9e�(�ZZ�h
��kP���-����
o_��~�����s
PK�^W4��~<c=benchdata/pgbench_logs_14_master_sample_data_100k_5.log.11040M��
 ��+zBK���t4sA���P�)���bY��jW3���]~�/�8O��IN�u
PK�^W!���=c=benchdata/pgbench_logs_14_master_sample_data_100k_6.log.11044M���0��Sp�2���X7N�������`�����B�<�2����5Dm���c7�#<9ZPK�^W����=c=benchdata/pgbench_logs_14_master_sample_data_100k_7.log.11048M��
�0�=W��P�?�tJ5���G �iov'T�cqBeM���v���g)n�;��PKW^W��"�@f;benchdata/pgbench_logs_14_master_sample_data_1m_1.log.11068M���@���P	H�0��������4C�eX�("�=sZR���H���^�+���G��M�PKK^W�5@f;benchdata/pgbench_logs_14_master_sample_data_1m_2.log.11072E��
0��>Sh���K�������$���W�m)y
/��(��&�l8O�{����pd�u�PK;^W�lBf;benchdata/pgbench_logs_14_master_sample_data_1m_3.log.11096E���0C��)4�%[N��b
hT�{�A��B�=����m^
�p���]'?"�;c�B+1���nPK0^W!.RM?f;benchdata/pgbench_logs_14_master_sample_data_1m_4.log.11100M��
�0��Sh
����TIs�+F� ,�3��E-�C�;�S��P	�1rG�P+��Qa�t;PK,^W���OAf;benchdata/pgbench_logs_14_master_sample_data_1m_5.log.11104E��
�0�>Sp�4mi���*i�'
w�*�����}&�+�25����,����+�����}��PK"^Wmo`j?f;benchdata/pgbench_logs_14_master_sample_data_1m_6.log.11126E��
!���)2Bc������IE��wEFi,d�����+Zy
���Cw]��AB��
{��>PK^W��nM@f;benchdata/pgbench_logs_14_master_sample_data_1m_7.log.11132E���@B��Va	(�O�o,���>"#�T[r �=MN!�T� j�G���]�Wp�6�O���p��
PK.^W�c���+6benchdata/pgbench_stats_14_0001_sample_data_100k_1.out��_o�J����R)�"g��Nu�UH-����!��$��kj����;�v�A����?�9�,��������G���i2�f�)k
f��W��X���/�u��j���*�#<��n����d���.P���R����{�@��*�6�Z���<52+^������*������w�ja��m�^��'��.Sj���e������!+�,��+p&!������}��d��
�Q��QU;*ui�LA^k-������	�`-1�?b�T�~g��y�;=C�G��9+�l&G(��T�l%���.^��5i��p\��%��L�_lI�Tr=���n:��n���������L�d��4pw;���{�H	g����n��)�<���gs|��l+��~�9����\����D�/w+�b'q}Zg6��j�6�#/
������>��*�����k�R��v��jS[Q��N�fe
\��w!��(��4�E�����������	�����
�)���D����z*�B�y���~���04��l����b�#�z���1��
���	����e�C��Zt:�N����wY�3�1N���lL�����)A����0m�\���J}'�<Nhc�S��L1��b��ca��^�<D�0E���z��V�c�������vz
����|<Qf�=o�eT���B�	~�
�Q�VF�d����l�.t����A�����=�j��
7�Fl��f�UQ��M��� =~�zo(Ca� �E����|V��}W*����wR�t~�5��JySQ|8���r������=c^�LF��H��������G��,��I���-cf�"��dp�)O�A���E���;�j��s���H�Ym^��
�N`�{���w[��
��� 
������-8���72��#Xq�z��z��TM:������Y���e� ����5y���!�Cc}���S��,
A��x�
����w�����{G��������_�&�/��PKA^W��[��+6benchdata/pgbench_stats_14_0001_sample_data_100k_2.out���n�:��~��H�@��R����(�N��gg(��(W����;���3�T�x��?C��?Cj�x/u�n\��R]�L��6�MYk0�����bQ�B���i�Q�g��������
w����
��@}[VK%G���e������k���yjdVlV�KYuX�lJ���y���g��7�������Z���s���@��-�J%u.�#�xw9R���� �-��Q�?��"�� ��jG�.M�)�k��+������H�����/~���si���@O���58f�����
�P�J��Dy���f�]��F���
�?����d���D�G%�g���1�M'���a2�2���x��)��y��~N�_��4R����-�%�H\�y2�9���k~��4������kr	����������(4�l���~ndEn�S�����>q �gw��k���$T��j�[Q��N�fe
\'t�'���!MD�CF![����=�I��C�B_P1����/�� /
�U�����yN���=
�zL��MC�a��*�p�9~����6��ee�1Rn�:�8�TG@��:i4���q�c��K�bJ<6�AL��&����>L;2Wp�K�h�@��'`�
mL�@L�~R�#������"&�� &�Y��y���H�����q6�	�\��|<�|��������";�|D��1��c�$|������l�.t����6� �������T^��nJ�P��A���O?*��q����:��P����ln�h��V���T��.c���]���_Q�����v.2 =�Ex�`;3/C������F���I"A�>
��,�����[�
�
+R����3�� e���w�e����`]�b8*���x�0����7�=����/���;����*��s�	����~w��8�YVb}�
����oe�`&����5y���/��w�?.�o�,
A��L�4��G`x�c�8��I�2{���n{pE���}2�0�PKQ^W����+6benchdata/pgbench_stats_14_0001_sample_data_100k_3.out��]o�:���s�R��R�1���\�v�
i��C�t����m$'ag[��NJ
��\�����3����Q��\�Q��(}90�,���*�,�������j���4��y�O�����[U/��2�7y��jP�����z�T��4M��>4/�����B��E[��c�+W��W|��z�!~�R�%,�*UM�2_��'�k���`p�<���������G��Y�?��l���	� /s�K
iU���X^t2����$f��W�H�H"�x��K�8z9h�Y��`58r@1��y�P�����}�m���~1�g
l_����x������Jn����<L��=�`<�>��<{��	Y?+���x4�Rpa���d����������t���u���o?G�Tm�*������v�<�D�<��jV����������Cb����������!>��V��e��jKS/-B���i��;�D�� ��(�rg���Y���QsL/���4�EHi�� ��47����T���s����=
Y7��g�&v�P`Aq��q-����QQ"����j���n)?��s��R-
A�%�^P�����(�(8�������!Lk2W����%�c�'`�
mLag���[�)r�na��&�La���7�:O+�#�:*�
��3�	�\�����;��	�Tb�h��	B>A�TFo�}e${�I�W�l�e�5��Q�!����']��C��^k�;V�V�EQ�x�k?����	�g���gVO��g�}WP�W��?��6��2��Rx~_vs ��x���F8���j�#Z��#��z���zu��GJ�l������Q�.�K��-c��z��������F�/��+�*���3�|K�QI�q/Gj������Rd�3F�����kN�b�[[kp��4�	���
�:R[�U���T= N�g��8KX�VucR������#��;a��D����9�)�M���A�=<��{M;�/���7���������/PKd^W��G�+6benchdata/pgbench_stats_14_0001_sample_data_100k_4.out��Ko�H��|������N���h�@#���io��;��v���������
��p������z4��{��'���B���rd�L�Yn�Z�Y-�
l�R�E����Fm��R?�����
x�_�lVP����e�Tr���^6P?@�J�M����4O�����U�RV]�?�RR�>��������D����Z���s�����kW���J��8\p�9��r�2cs_A�[6���O�y��YP��R��������XYmd�O�Zb���h��<)\<������^�Zc��lb�=�r�b�J��VZya��&����F�{�OI`��_��'���$��|��?��p7��{7�����?���n�`��Q��9�~�{�H	��7�^��������x6�o������/����&�p�a{���}�"b	'~f�mT��PFBp��6���O����|v7�����}�_Ym}�!Jy�i��B���(��N ��-�;���A�^D�v�HX�I
A
y��R��w]A^�W���bdB�G$����t�y\����Y���7�;�������C�E�����r��)/NY��O�C���^<R��������zS��C������zV]��+8>�R�4�0�]L��$l�Iu��H:&W*B��3�S�I.��y��k��Y���`B�9�����oV@����L	Rj����2
�3�-�s��fS���U���Rv>�;���� �g�@5���@�r���GU�d����B�����!z��P����l�}|W���Z-��R����C%��[��6�]�����������xg�f
^���;���N��&��e3O��Mn�0��u/�f���B>��>������9��=�N������hL+���������Y�C������v�0+N�0'��}���Z[�UH����8=��<���K��s��&�Z�j"R{�O"�MNH���C!H���{���!��,�3sl��D�,���������PKu^W�?2��+6benchdata/pgbench_stats_14_0001_sample_data_100k_5.out��Mo�L��|��TJ��Y��S����Bj�SJ���coK�5��M���8��;`�CP�?��?���;��G8s�\��|��T5i��J�����(V����h����4Y*�����+p'�[Qo��r�7E��b���N�P�C&�t�����Z����e�\�m	��u!�~Wk�l��
�>����X�U&�F�(�4��i!EnY]
�3�0���Od���H��:}�\��	~B�L
U�"��UJ�WbE�"sx�:�^7�/�K��s8{*�c�j�1=�4�,�b�=9��B��(��b*	���v����/�y�u6�`J������r
�����)��_���-�g���N�����l��t-����<�a��g{��NK|[��<-?}�6��j�L����A�/����"�g1�F�������������>��2[�\���;�-1O�-~e����(eU�t�1������B��;AH�l#R��bf���GNB����A�2�D����k*�@�9w��O@��is��qb����I)f�
\��KW6�7��ee�1Rn�9.#�O �Z������N9�,=S��	����"QX�d��iG��w��;>_�x��)H�����l	&r����b6�
i�C�B��
Zz�����wV�!��'`��j�������z3��+MX���ak��>��������T>��f�Z)�?��Q�!N���*��
�$���������A1����u5X��EO��2���E����]�Or��k���2���o_]V�J��'A�������f����sI����l��:��Ro4J�B\[H�'�T�e�-b�d�8���9Ei�4���If,I���h$_�;Q8�%��V���{��S+�V�O��bOH�����X�����*��1N`Er��/e�?*H^�t��g�b���SU7:K�j���E0����w6�������IW4�d�P��Lx��������������PK�^W�����+6benchdata/pgbench_stats_14_0001_sample_data_100k_6.out��]O�:���+|�����oV�b?�U��rN)���Bb ��tg��~�����d�^�R��O���;m�Gv&�\���|���6i���2�Y�+��X6�����/3i������������ju�ae���)�����w�f�=�L��k�������i��e�>e[���BS�a_
[�w��W���{��a���t����]�}Z���+&���B���:8����u�>h��R
��8fe3)l������V�+����J���_!_"D����=V�c=������%�� feaL�h��p0��l��
���_�K!����L������ ����b�y9e����S6�����"f�s���A;v{3�gw����u`��e�a�e"p���f�X���z�i����)k���4���[���a�*���p��t�������H������>�
������-��q�$��WV��v�RV����!_�(8�B���  �����e��#�V��� ��G������
?M�m*��L)���#�m�����R��+����]}I���yV���St���1t)p��Z�y	�|����#��~[�����a�cR��i�0��\���T}98�L�`S�m��~2-�1qSW
��G��������*��F�}�'c��� ���j��������B	��;A�'����P1�����<��fe[c�?��Q��"���)�T*�I��<�fz����C1��J���^��=�P����*��w��~2��][�W���?���=��Q�xDz��zH�-M�z�z!��a����(L��G������#���!S�����4���3��}���N��/���!;AVEw���7x)8{��:�&'�
�K�����[{p�UH��`E���!��z�
�/P����t��g%a(!M�z���ei�_CT�x����7��o�:`��u� ��8C�������`��
�y�(���?g�O�?PK�^W��'��+6benchdata/pgbench_stats_14_0001_sample_data_100k_7.out��[o�J����r���6��=UzA�)9��o��7���M}i���8��3�.�� �fw~���[]�p�����������I�6�Jh7k}��U^f�I7��i&M�����;�U�8����7PT���X=)��V�P�Ajr]�M���>�:���,����
��Y�����j`��m�^�;$��.1f��Ju������.�����H8�BJ����$-�������{
�q��D�P4����<1�Ve�_����L�J��v��G�����1o���
��I�������������+���w5B���%�#C��$�������-�#�J>/��S�������l�e��<{��9�I}�[��>������,X���� 2�����t������������T]�j�|�=�����**dA,��[��F"R<�/������d�/7��=��
�����V[��������X����G�A�<@�E��b��"*�vB�X��Z��w��1H>&:Hij����������Jk!S�^�.~��L�#VcD�P`hAqE��-\D����L;
��TL`u����{����/���7!����j�K�b
I�c����B0�n������b��G`�mL~,"���L��i��l��k9c��e5/�UZ�~�d;+�J"P��}��r���Q�)��2-�7���X���%3������<&�fUv�`�c��|��b�%�Sa��hkOZ�H	R1:��S{�Pz-n(c��N������lV�]n���=��7��d2b��Y�P|hA��n`�#Z����F��<���=�z'�T�q�.z����y�,��!��K���z��0o�S��L�������#���dv��g�s����S"�G��I��;6���0�v�lV��������+�x|��e*��d�+��
�rp���cU7m�4��D�8�����:�(x��?�xK�^��w����-���{d���������'�
PKj^WY����,4benchdata/pgbench_stats_14_0001_sample_data_1m_1.out��Mo�8���sY )���b�0
[g�u����$(���&��K������>�����|��p�z�Wu�".�/�/=�fu���lj0����W�����:���^�g����������W�������VZyu_����u�j�mt����UY����^�����c[*�?����}��z���~���kX�M��NV|���R�E���8�\z:3��k�~�6{T�'�%Y��Pu^Y���4�M]�7de��c�/7������qp�\���7p"����]��'����CUj]v��{��x�{�ZJ�>�	����
>O�Mg]I�����bw��?w���N���,^�v&k�����7�7�Rp����e�O�L%�<�����kq�������	tM��
�?l�p����c�1�3�lwu�:���X�u~��)q��b~7��
��!����7V������k����D�
�7�PM	)R�'����c�
FX�����Ha��A�s�DW���������2_�K�g�l��,
KB�M�F`Kq��.�
le�����|��?��)��H%2f>5�R�
�0a�n��$R�vK��$X$H��$#L�?�iG�
��R��,�I�����$,���1�cJ8V;�\i�3N���H���[���\#�[�m��	���\nm����$o��������q���	�6��sZS4��������l�-�^k��~��� `)��#�f�S�Q�$mx�fF[�H���U�<�]aDz&�g��2��T�,����Z=����/�9Q�R��@/��6{p
3�c�9�A*��v�!�-��9c^L�xt���w6�8,��i����+B�5�9T�X|�}���X�|':�YZ�����S����z�.�jd��T��-[R���h;&�;���[;p���(y#X�:
��]RoagE�������J0]�M��<��6D���� "q�}��0�Dhg�A
�8C��=�����x�</����h����}����PK� ^W�����,4benchdata/pgbench_stats_14_0001_sample_data_1m_2.out���n�:��~��H��!E���,z1
�s��gg(��$W����K��M�#U�"�����s��O�L������-��D�I�$����f-o`�X�e&_eC�_j�����'x4���
6���zE�}�k%'e[<��GHU.K�t��C�\�$�>,���h��Y���q5�6�v^o����w�(��u]��idf����1�����pA	����D%��}�oY'O�
�=R�y�f����iU��
Y^lu$�i'������~���K���VC�����f���v�FE�T�H#����l{[J�(a����|�~��?������b�y9������)�����C�g�p;��OR���l�t-%\X�.��=F�h�z�������Z��=-?�1��j�T����B�r/$��M,�����9;����o�����C���~����y�\����r�RZ���7B,�&	<�~�#
XdPS����<��G�k`1Bj!�(�!H>�]�)M�_]A�k�WU]W�Gd�LR�PF ��<���M���3..�����F""^��?+D���j{YYE�.)���dA��A�����������~N�Tx$����K����>L{2W�n��#�D
�c&���)��u���T�0E���dK'���a��[����H�f�}AI��ZA��e�`f��(B}����n�1�[d��4x�A>�P�%�)Q/��Y��R�?��Q��pL
�k�������"6�������*��EWl�Q�����isCjV��^e�����/j�zhs�{����������`�rB��d4h."�E��v��Ox�����:�sR�\����l
u�(K�%�<4�t$��q7�����H�#��4=��Q*�����Y�M;��������d��tpv��^?-Kp���V���2���in��Y��]"�#X�:
���!8��EC��,�����g�N��a�R��N�F�L8�7
��>pt��G"$�/.������kd�x��g���CS
�!~A���s��4�PK�!^W�*
,4benchdata/pgbench_stats_14_0001_sample_data_1m_3.out��]o�:���+��H���6]����V����dS��E��@����;4MbO
�6�B����������8�2W��>��&��43E]����<+VE��'�z�O=i�T�=���n��O~v��@Y��o�r�����[�@}�.Te�^wxh������(��6�����ZX��m�+C"��R�7�n�L���Q|i���B����g�c��u>����o ����^����$LB���vRT�)R
Y]U�YQ�:�����n�g�PJ��ca���@���58h�+����PZ�By�+����w
R����<�c8|�������-��p%_�O�)��g��La6�:��"��9���Wn~�����4J��E�|��gq�E|6�1],�ky�������)�u�d
.?l�p����C��.��Y�������]\�;$p�rq3�����?q�/����1JY�U���	�0���w��"�8�|��D.��h�<!+�9j.9�OvrR�����e��. +��u�U�
�/C@��d��`\��e�M������,\�V$���QX>���de��5R�<)�a?���Fx���xB�j[��X��2�� !kq0�n�������Db#&�z&����K���Iwn9Q����"&I[����~B���j�#�K���c�F�@��e{K���!�������
�	�d���bA�F�F��t�7��1��������U �3B��)�TR������V��Q,���;�+�GW��3xCkVw�Y��}P�G�Y�v�6��C�=��}�s��F���#H
Y�l��hMz����c��F�9��f�������f�,��R�B��!��#�|���8���$G���9fdS���(��7�	�pT��d1^	wZ{����l)6�����N��I�
�:���+<��_ N`E|HOF�8�-RY�M���K��[^J|�lV�u��,m�6D��Nb�vs�(�!��������\#�;�D�WTzF1����u���l�q�PKW"^WTL��,4benchdata/pgbench_stats_14_0001_sample_data_1m_4.out��QO�8���)��$X!��N����]�ZU�-wl���
��H��M��~�u(��@L�*�f�_�?6��[��8�D%Ku:1m���4u��l����ZW�Iv���&]Y�Z����5�D�_�l7�j*����Z���W����JUKm�A�hZYT�W�S��W����%������>�f�6&��}���mS���������V���.��	%���N'�0v�(~�����7Dq*A8��&��M]((���z5�b�l��ug�,����6Mo`$�t�[tew�����V����Wvg�z^{�ZJ�}(�(���|�~��?���'���z�e1������)�����C_WOp5S��������;��VJ8qh��2��&$��l�sz��_��]�����L�k���p�i[����
�HJ3?��t������<��������������r�]��9G+ya���C���������X����B#J�M���#�o���p!5����:)i�m��T :��6��j��b��bFs����~���X���$i���_<�����i����}muT?��1�{���A�o���G�r��sB�w��b�	K�a�y��T?�iG���R��$N��d:�2�I��I�>�x|B���zx�!Li��b�-�F
�H���WT�n.�[������qC�LB��M�N�I��<��Y��SfS��M���Rv>}4�������<�j�&�`�D���,��*|�9}���c�Azx�y��������l��}}g����,o�Z�_�<!�����3I2{d�i#�CUz����c��IC��
z^��2�2"���}J����q4��-�Zc�"=���s�z���w��b6�0��
�lU����=��p�!Zh{���6���B�������g�������`�|joM1���|VxO^g9}EI�/0��"{�
�3��3e��mcq�������hO!���A(�������������������Zc����������PK##^Wiy��,4benchdata/pgbench_stats_14_0001_sample_data_1m_5.out��Mo�8���sY )���S��Fa`����7C��DE�����#;��q��>������h�!�~��:���T��d��rS��f-o`�X���/����j���*�#<��nn�O~v��@U�o�j��Dw��l�~�\�R�����Ff��a���UW�����T�Wk|��z����L�
��:�m+_����T�p�n���c]NTf��
d�d�=J���b�z<eP��R�������YYmu��i/1���I����4Oug` �r�\���`�:�@1T�Re+Q^`e����k���\%M��a���f���$�W�e1�����|���f�����+������Gi���l�
�M#%\X�.��y�p�	��<���.�����gZ~�����kr	�v}�~���/H��t������D \�����Cb��#^.��_z��bNp�����c�������"�����B�"�Xp�1�>*�'�`1"�@x�`�zR("W�@�s�DW�����*��L�4�����	��5����^�����.�4t�.G`����a1W���YY�{�T,<�W|��
�z��|����lL�<��<v�&�
a�������E�E�|L���)����QL�#�H9&[pt6��b���Zo���?F��(?O�d���lo�h���y�-���l���A[���F������FfS���M���R8��4��$�8;�gdR��U�1WoQ���
�s���8��P����lV��+��YmV�]���/Ez)u�	��=X���KR��#\z|x�9Z�fHG�(<j2��0B�i��QFi�%�#'��.K�_��xt��#�#���&���h	������x��EQ�����pU��dw��,����+�-�mK����c5�w���g��{F17�	��O}�E��D{�=@�,Ng9��#���	��a�\7���V�B|<=����P�[��0N�������6N�� �;~���2�C�6t��~�>[~��PK�#^W�0�D�,4benchdata/pgbench_stats_14_0001_sample_data_1m_6.out��Ko�8���sY )E�L��>�����u`o�"1��r%���}Gq�cK�|�`�?C��ym������E��%��L��j�L����xUl
���8�O9k�T�PW�7�f?[Q���r�7E��b���^�P=@&�t������i���L_��-���.���j`���^o�����R�`[W�h�����?���eu.\����]�d���;H�:}�70/tc��8�����E*!��o���U��Q�I������(�.��T�L/g��EK<�WG(����h�s<��_���Hi���0A�q
>��-�MI����j�i=������9,�_��C[�/p����B�������Z�0h]<�$/ �/�?��5>��O�O���CS�u&���~���;�,tbN����]�{�N�q��]��;$�1������K`�C[����������U����'�����gRQ� "F�l#RG�f�0#��1v��V�A���
�w�e��� +4~���*�G�y	w��m�g ����1�e�z�Z\��\��'N���bB����2��)�N���3H�&(�y�x�hd�6'�&��z�c�(��0���I�C�d��T���0��Nl�g`�
Lq�;
�'�lmL4]
L���u
��\9M�MV����oV�g��(�3�����Bl�!��Qn��*$'�$;a����h�OH���'�M�|Nw�F�Rb}�S����	��q��J����n�L�JUL��A���xBa��Z�qB+V���x}W����m��B���dI�y9�7v{0;#^C76>� �H��,-�&s�����a��z�Q�,v"6��Y2���$����`�
6M��o�c����H����pX�NW�z'v`:Z����_��j+�V6�	#F������;��8�v(oz�#y�F���NSW.'�f�)M[����������p�����P<����z
A'x����ng-��]��;�3��h����}��8�
PK�$^WP���,4benchdata/pgbench_stats_14_0001_sample_data_1m_7.out��Qo�8���)���vU�6]��n7ZE�M���to�E2��m��
M��IC���Q������x�p����D�����Ol��M���*�n��
^�����nX��L�41y�����+�_��7PT���X=)��N�P�Cjr]������Z'���"y�����?�\S�~_
���6���D��&�l`]W�n����/�Or�3'�
8�q�9��|b�g�@�[����?Ax��}�xE3�������*K��,/^t�����u�?��a��=���j-	=�4-�d�]A������(��de����FJ�}8\���
�N������@)Wr��~YN�v>��v
��������3���&���p�s6�w���z��w�E�"���<���.�����eZ~������S
���}�|��/������nw���s����������X��/����v�����+~e��]QJ����fO(�%A��A�������t����c�(rz��Zz���!H2&DHij>@t
in�����b����<N^�d��{`O��IF�%%|W���h��EI=K�:����z�{��'CL�?��RJ�a���DD�}�z=�,V��a
1�����0��\�{]��*`�O�0.����i���u1��8=L}��,
H�b
�Y��Vie�1��F�RH4,�#�s��bW��#o���&��`]���|p��A�|�!�%�)1O��Y��1��>jTR���w<�jB:U(��3H39hUtF�(�b�c!��6Lo��,�P�����W��(��������#��<�����=��(�����#F������S�yCS������(��=D����tY
����Nvr�8�9p��4zk�I��O����LS��C
W��N3?"-��������,I<<;�+&�w��am���X�����FG|��I���FP��P:��!+�a�T��M�FoC|?�i���Yo�����}l������\���6{'Bv�|�}^p��"���?f����PK�$^W�:���+6benchdata/pgbench_stats_14_0002_sample_data_100k_1.out��Mo�8���sY )���S��M�����u`o�"1�Jr%���}�8�9�H�}�a��!���p�~�SU�g"��o��'�I�6�LQW`6ku/�UQ��Y����'m���z�{���+�_�j6P����E��jRu��j���L�2m��?4��J���e�\�]	��M��~�������xC"���Zo`���j[�[��+�O�rdu�8���u>����o ����A�� ��%�2���Ua�TCVW�z%V��L2����[���KB�p�T���30`z>i�]����vq����,�.Ze��
��_��5��^�	����
�N����]I�Xr��~YN�v>��v
�������3������2p�s6�w�Q
�X�;�",<�y6�9],������������]�)���]���~�2`B�.��]���"���o����^b�rq;��
lw���c�+���j�RVw�i6!/b^B";�Pu��Y�FT�-�8��Z�,	9V�A���j�<���. +�}�u�T��L
�������t�%1���``���"19��6���$�p�~V7��)��H���8!!A�����I�tR|�S@�n�9R[�!��bD�0�n��x�K��/'�>�]���LHRO��H:�ru0�R�)��lS��#����j�_#�������\_.a���;���)�Bj
����c�s��F�(�X���#�)�O��]U���?}��d�d@���)�TB���'T0���UE�%����dxJ�$O=c'��fu��Un��*��7����f�.C�5�������
���y1q��YB�d�Ci����F�@��G�z(�NGi��k���,c�q1>e�nsX�Oy
!?:c$�3I��3�!�',L��A���r��9
���;�R�a��{B����H�
�:��7p�@��:�� ��{�4��@�2�Jbr
���b�T7���V��H�KXBo�#��9r(����=:�`
;;C��G�w,���db
������c��<�PK�$^W��v��+6benchdata/pgbench_stats_14_0002_sample_data_100k_2.out��Mo�8���sY )F��S��M�����u`o�"1��r%���}Gq�cK�}�`���|4��~��:�3��T��d��rS��f-��E�*u!�e��_j���*����n��O~u��@U�o�j��Dw��l���\�R����n��Ff���*{.������T�[Wk���z���]���M�����/m�}V*Y8����3�y����De�����l�	��0yP��R��������XY��OD/1�b�4�9����<����������n��#CU*U��nL/K��4��������
|�~��?��0���z1�����|���f�o���+�g�����i���l��L#%�Y���#�0ei��g����/���H�/_��B[wM.���v�O��������YL������O���-n��q������u`�BG,�������c������X����>�w!��(Y�"���B��-FD-b��$��P�������D���U�����	�J��u�~NX�0_�q��W$\���������j�`);��AVV�"���%����\P~�;'EL��r�\�]z'8�S���IuC���\�a�J�C�L8��)���I���T�b�I=Y�l�Y���O�h6a���Z�m�x/��3A�v,�G��Y�C]*t�n��|u�Q>��^��#��L=e�v�;���>4*��("s��8�E������[U��-����G��E��b�����Y��fU���-��fu����e�]�?�_���R<��v��Bo8-:XB�q^@�G�zN���2�m����)�$`>m�z&�@�!���F�R�����hRt������6w>z*3��[mi�;���3��8��!V����>�{x�!�<���@��,��rY��H��1������X=�Mk����C�&,�N/��@� �>����>��!��g�����A&>g1��7?~���'PK�$^W�����+6benchdata/pgbench_stats_14_0002_sample_data_100k_3.out��Mo�H��������"���������v�n�H{C��I,5m�nO���2$��XA������n���-�L�K�K���kr����jn��W�Q,*[�g��O3j��T�
�QW7W G?;��aY��o�������w���
Si��^���=6:/7_.��j�-��gSi�����
��f��������5����m�K_����2�$QW �LB�?�G&w��5��t�?h��P�d��U�rUn����/���FDY�K�����/�	f~��c�98z>j�����vq��bXV�T�Fy������AH#x}a]"��K|�|��>��X�������|���?����N���*��z.o�����7�s��p��:�,�b���������������>�5����B����B.w�8P��yn&��v��)����������bE�ong_z�
�8T1�����C�����Y{��$�RA�A��!��@��&�����e�~u�S+���� �!�O ��
�(*�M��!S"Ed��G ����e)�~�SAq����E�hW�2���~Vw���t���I���|���
�@r���c������0��b�LL0���W2���J�����pAS�����X�z�|)b��S��	*���(j�#�[Ke2��~.���i��a��2����&{'���4h�O44�������|�.lg���*52y����I%��������FU���(�{�*:�	���sxCV��Y���]��Of���*��e�.
Owe_�_x^D��G�#��5��j�8�bzu�G�w:�Ll��d�#PZ�2�%�5��2N�i9�P������MgOw�G,����AW%�������V|�P��*��`G���8X��C����
������V�[Q��<@��b�h�,:���G���2��z���y�_BT�?�����-�G!J{��GJ�-��P����x'�DJ���L�(H3����������PK�$^Wq���+6benchdata/pgbench_stats_14_0002_sample_data_100k_4.out��]o�:���+xs�v(\Y�L�]l]08K��R`w�k��
��lym����MD���\$���"���y�Se�gn���J�OL��M���*�l7�
^�����j����4i���
�QW�W�N~���BQe�o�b���l�;UCu��Ui�Nwxhk�d/��9/���\q�!�6�l��
�>~���[��U��Fe(����I�UF��@��p���Otb0�-$�U�<(���$�J(�I^�&O4�UY�Wby�"sdt�i�+ZL�x:����<V����Icp�����
�P�Z��By����K�m��&���+^��������-	dH%�����n��og0_|���6���f
&������7�3�Rpf�:�{vC���z�/~��+�X��yZ}������S�v}�<D('�$�����:�F2r�+�]���'����W���u`!����WV;����jKSo-B^����B�"?t|PGQy�(��b��2r��HA�R��� ��47���n��t]'�,���5-`��N��������X�X���5�YC
�
�c��ee5�{��H��1�#H�x��y���8�������|yBM�1��`�m�72�������pAS:!��I���\��0���{J5�-���N+�#�����#��Z� `�"��M�ew�[{SFEP;�d�!�y�O�"#|������d���Vk�OT,�t�	�TR:Q�
��L�Gk�br4���Az���g��24��U��p�.�TOz��ksm��2���X#�u1��;��h�X?=�Ex��i�=��^���;�/b!��(K�2�7(�e��S��dp�q,�x����-+��+�"����JjO8So�VfJJ+*=����
���+���qm���Y���(�-!9xh�)��T= �w���s�����1i��W�E�#�����,
~���G1���#0�����c��}�>�L<�������}��8�PK
%^W���g�+6benchdata/pgbench_stats_14_0002_sample_data_100k_5.out��[o�8���+�e�������^�����u`�Eb
�JT�����&�k�!F��!���!�~��x�?)�/!/'��U��j��Z���bU�R���u?��+rY�Gx@]���?���vuS�����������

Y	��A���Z���������?������:X��m��D���Rn`�6��:Q����?���5�<����y]Nd�q���6�7�^�g�)���R��r	E��x#V��2�s>H���_�^g^��~jz
#C/'��9k�l'G(������K��*_���i��a������l�����oK�,���S�������l�u�?�U��s�y�(4�������n������{,�R��l�c�X�����������5}[�������~�<b<%u����k�v�g��]��;&��/w�/��
-1O�J�Xmk+����n7� fi���N ��1��.d#R��"��Q��E	Y�R����@tE���l�P�2���
��O@6�i�=��nO�WB���ei��IJ�����bV?��h�c�p����]�R�
���!�B��p��Q���1ey�NL����V���w2Wp<�R�B��K��	'41E1���'�L��60�R��ua��g�i���F�H�k��c^��8��Y��-L�  o���vCm*)g7��A�N������l��s��V�����A�,��?�r�T���w������E[�c�5����"+��i�����A��_�(�,7����z�/��%����`�W�b36>A�������$;��%.�)=�z����4=O@�(�4D+�:��q3&�2/4������chu�
ba��{>1���^S��{�z��L)Y���n���v�w��zg��|����"�
9��=�z�f��)�Ur2+�'-t�zn�Ny'��� �,�<{�	��2(�ib�9��qNO�������
2�����������7PK%^W�g��+6benchdata/pgbench_stats_14_0002_sample_data_100k_6.out��Mo�8���sY )���bmj����{3�IP�+QM��K�IL�#��6,�3�<���wR��p��B���|b�[����`6ky;����|�-i�I�U������6���fU]X}[Vk%'���d�=�����[���yl�(v+�\V]��M)����������>����RX7u.�VV|���E�d�Y]
�3J(��O�06�
����F9MI���I�KS
y��|!VV;a4�J���_��,�4����<�����Ik���
��[VU�T�J+/l`��m�k,�	�����pxQ������GW&�/�^L?-�p;��w;��������n�`D� 
�~�����i��3���g3d��l�}�X����������L���&�p�a��������(��,��]��E���_7���C{,�x���_o
�w����_X�}�!Jy�i�lB<%Q��N ���1	�AD��Q�|�R	��((R��� ���4�]���bd
c$����d�5]`YF����>���r����������zY9E�)�0B���:����������&|���0���0������T�$_�vASS���Iu(�P�8�\�����b����[���^#�[Ie
�!:���\,�mm
6#�%
�/�w�,� ���1���z�v�;�l�m�������O�N�������)�ZUB}�CQ�^�9��?�U�N(C��^6���h��6���T��.���)��	��{��WJx6���� ����iw�����P����=/�����8��N@�1�4$Q�b@S�L\���qD31�](�g�C,�ss���bvU/���� /�Q�������b�p��;���8�^�����?�.���&�Dqn�������Q���b�~=VOu��\���$�����{B�o�
aj��4F����f�����X�*N2���o�}�-?N~
PK+%^W��6��+6benchdata/pgbench_stats_14_0002_sample_data_100k_7.out���n�:��~��H��!uW����(�N��gg0��$W����K���[�}����!����d�x���	.D���J_�L#�Vf��+0�����bQT�zQ-k�Q�I]T��`uusb��S�
�:���(�Z����W
���BU�]��_��F�|�e)_��+��cS(�������n���>�}���+X6u��V�V|��d�U��n��g��w�#-�=�
�o��G����3/M�lGEU�Bj���R��F�|���ek���(�\<�����^�Zc�,��`���`�PZ������7[�i�/�������_'��$�b,�<���n:��n�������N���Q��9�~�{�(��]f	&D�3O�?���}���f���mm�5�������_�w�ELD�������
���
������9�|v7����!�g��]
Q���2��!��,�=��B�
� bQJ��U���
#������� �
�b)���� +����uS12OXS�)�~���.�4eqJN����������^h{
y��Br��e��1R"�,
�>N �aP~��pTG8�!V��G0�g^�BA�t������R����|C�]La��h�����;�+�����|��[d�^_#���Ra��]����^��O��Am�B1���'Z�(!�
���!>r�7I�,W��������F��R
'P��S	�c�7�,y���~o��^�},tW���3vBjV�Y���]A���jq����e���|W����W������li`�Ci-������I#�!���2�X(H�=
eEY&��@G����;dP�
iz�����;�!r��c>�={�6O��i%���J7w�Y��XL�����[��0����V�[��x���H���c�W
K��/;]�c�u��L��o��'�}l����K�P�5�|�b1�]�ao��8a����}?`�
����'��?PK�%^W18d5�,4benchdata/pgbench_stats_14_0002_sample_data_1m_1.out��Mo�8���sY )F���{��Q�:����P$&@I�D5���(�crl��1��3$�;���U�=��r�K���i��M3S���Z���bUT�zQ-k�I�����
uus|��S��:G}[�k�&UW����t�*����C���4}X�/E��`��)������m���?$��.�z���T������!-�������c���u9����o ����Q�����=�B/���Ua�TCVW�zCV��:&��%f���}��!\<����^NZ���x2��� Pe�u�*��x�*�{� �	�>�����
|�~��?�� �\�����r
w��wS���N����_�v&m�����7�7�Rpa���e�I�3�yn����t�����.�������]�)���]����}�0�C,��]����HD������wH�'�+^.��_z��bz�7V������*�l���@7�	�*�(�/q����cszl���~��P��1H2!�HY����
���O]�]���	!=J����k��q�I�Kr"F�%E}d�r�~�� t���hm;��AV�����ItX�'��lP ��B��,�|.'�:��gI�E�s�c�N�&�
a����c]J�q�dH��	�pAS�,���t�b�=Wma�������^���Zo����F��(�K
{>
;���Hx,���r���Pb2�
]�	B�%	-#
������T?��vUuZc�S��Cl���*%�*�i'.���*�J�(�b?a^|F�
h�:�N(c��A5�_�T�YoV�]���/y,XL�q�~�1������F�{q��9Z��)�a��;:��sJ�l�
^�%t��e��=a��]PQ�Bb�X�8��g��L���u~%��M��y1\��;y?��Z�T��c���VD����G��!V���g��C&��w+��@09���t��-EV�$
`�g^06�>�Mk��U���sp����hO!����X�����������#8T�<�L��C�^���}��8�
PK�&^W��Qs�,4benchdata/pgbench_stats_14_0002_sample_data_1m_2.out��Ko�0����h�B���;l]0��-K���V[�����|��ISKL�%9���IQ?��w�L�3�W������IR�W%1���"[�*/3������&Mt^>�{�U���?��7��2�7y��jR����IuOR���4��hk�d��E��mA�?�\a}WC��l����!|������T5��@|i���\����"��1�{w>����oH�W���"	�II�8$E3�����&iU��Y^luTr���u?;��=r�����5d��|�X������������vVf���(M���(g��/��y�u6�`K�@������rJn����S2���&m�=��91I����5�%w�V��Y����yH*��z��MK�X��=-?}�6%M���"��w��|�P���a��YLwQ��9;1w�_7?��2�]�rq;���"t�B��V;����jKSozB��4��*1� i�G�#Qy�m8 ��b����]�$��XHi��������w]u]����C���~�n��d@%Cn\``�p
���� I<�jGa	$v`�����{�T$���A��A�8���K�.=���8&�����!L{2��.%<����`ASy4���n]L��X�,)1�
j9���1L������5��XI��c(�#����
�_�x����
�s��
#�6&P�0W��IFzS���M�*[��?��Q�n����	�T����
�4��V1WoQt�2�Q��u�^�z�C���2���U����.H���fu����%�T���ge�U�~���g�XM��z���f���;:��sR�d�~�i����tYr)C��^��q3F��=d�4���N��E�xz&��Y �8
�b��}wvW�p����eK�l|������:�w���g��.���9��s1qn���*z)\n�ax��`���Z�SU7&M�3!�04��}��_��H
,:+����CH�Y0���^�����H����t}���l�a�PKp'^W�NQu�,4benchdata/pgbench_stats_14_0002_sample_data_1m_3.out���n�8��~��,�
CR�D���M�����u�7C��D%���o�qG$��1��C?��������G8cq�~+}>1MZ�if���Y�+xQ��*W��%�/=i�T����n��M~u��@Y��o�r�����;�@}�.Te���h��/���(��6���}^-���n�+����K�����3��*G��-�O�r'�
(�QB)��|�S�g�@�[5���O�8����H@�N��0E�!��J�"+����J�����%�	�=���	=��7-�d��A��B��U(��dU��{� �	�?�0���P�/�o��G[1�J����)��g��Na6�:�	]�?��L�<(�?f�opg����u�_�%2$A��<���.�����������)�u�d
.?�6�p��a�b"��]g1�e�����G��������8H<�rq;���e��)u���vkWC����L��	�AHh2�P�#�'I"��\D���Y��
#O-"v�C�B�]�)��_]@V��������Jy'=
�v�����..��-\�� f#*J����������]R,!���R�
D�>�Au>������"C�Y� ��;�tw�����R\p�n��L���I�1��A����)>^N�TP�����^�e���*����_��^n�Q'���{K
�}�y�Ao��z�D�8����Dc�i���
oJ�S�iWU�5����*����G����T��I4|��V���E�cu1�%9H/2v���Y��f�����J=����+�9���:���9X���H�%��������gk�����/vG�
zN��F)� 2�����!�"����2`4�+����Q���}`����ff���N ���w'�_L~�y��JuJ������1|wRW�U�1V���g�J"B����>����>���4�.��9��Y�.���iM��j�#�D�w�	�[���������]�������,k�x'�� �cL���K=�����}��8�PK�(^W0|�\�,4benchdata/pgbench_stats_14_0002_sample_data_1m_4.out��[o�:�����R��\��wu��VH���J�
���Fr6q������b%
<���?�������8Q��(}>1MZ�if���Y�+xV��*WO�e�o=i�T�=���n�@L~w��@Y��o�r�����[�@}�.Te�^�h������(���BQ�~_-�����x�D���Zo`���j[��������V�cu�8��8�����7��QMz��RD��d(�l'EU�"���U�^�������%f����a,�g��y�;GL�'��EK<lWG(����h�s<Y�?��k��v/��`��_��g�O�$bW�u1�����|���f�o���+�'���I�{e���l�nM��Y��w�E�L���y6�5],�cy���������k2��}�|��'&���nw���s"��������cb/!���f������9~���w5D)���4�=���ON'TQD�,����ET[��k`1"j_�P$�zR � e�~�d��w]�U���I�LJ�#��k��	_$,���������pWn�r�>g>��v��]��;��J�7II�s��G��lP��	$	�|�S<�z6&�b�L~2S�;�iG���RX�|��u=.ha�c�<I`��t7�-EL�<%��wRo���o#���'�`����/;�"[[@n� �^M	�{7�������������T?��vUuZc}z�PaS����Z#���RE^�bJ�������(��V��4���N���gpB*Vw�Y�x}P�G�Y�v�6G�RF�>wW������A� �����w�=G�K�y�����B������(C3��F��\�X�bLr`2eP���
����,�'����[%�xz$���/a���W�{��Y�;�������aK�����0y��by�X����*�����V$Oq����2G�4�,���|�9�w��c��&K[�5�?}����������0/��3�����ft��`�a����c"�d��\���s��4�PKp)^W��
�,4benchdata/pgbench_stats_14_0002_sample_data_1m_5.out��Mo�8���sY )E��S��Fa`����7C��DE������8��q���!������y�����P������<wt��6�uY+�����g��T�x����N�g�T�p�������D���.P���F
Gu��h���\�B���
_��Fd���U�TV]�?�RP��W�n�
�1�w��[�4u.�V(�4�wY)Ea���<������i<��_����
�%q����j�R���$��R�YY=��(�z������C?����4�,=wZ��Vx2��� PU)e�
�x2U<��5H����s����>���MI���r�i5�������_g�CWOp��5�B�������F83h��#�4H�4
������r�o��}���������&p�a�����}�]����]VCn��8�l�����cb? �W�����.C;rB"����VS���S���B��Q��xGRQ���������=�����)��S�BFeA�s���K�e�w= ���]��T�@��9cA 0R�60\a�J���ei������N�: k��FY�{�K0��x�R�	
41������=r�z���������<[la���=�x�Kq?
]�>�#0���$�]����1���/��&S��xL�:i=N9��:�e�/�|��sZ�G0c���Y�%C�8���Rb2��6���m)md�|�I->�Do��c�m�����{���|��7��t����'6���U�mq�_�'�0����	e�Y��f]���%�v}��R������G�We��a�0�8�4&� �H��,-Z3���$�`��j��Uz'���Mh�=��Y�5��IDJ�L&����(MF�9=c��MJ��J��G8r��r1���;����u�:���R|
�p�|������3X�c��{����S[ve�=���8��
���"�X=�M����%<L�������@�0�8��t��)���aP[0�X����o�1&���������}����PK2*^W���?�,4benchdata/pgbench_stats_14_0002_sample_data_1m_6.out���n�8��~��,�
CR�D���M�����u��@��D%���o_*�mr��1��C
?�3������'8cq�~+}>1MZ�if���^�+xU�U�^TK�_z�f�.�Gx����6���f
e�[}[�+�&UW����t�*����C���4}X�/E�����)���jae�mV��`Hd��T�5��:Sm�r+�t�i�U�E]
�3J(���Otj�����VM���0Nc.I�#(�IQ�H5duU�7dE��#\�^bV���/(����0Oug` �|�����6o� ��B��UV���U�k�]c)M`���Q	��2�6�t%}��b�y9������)��_�?�+����I�Ge���l�
�M��9���+s&�_y6�1],���f��������]�)���y���]�
��h��&�}n���|����C� �}�rq;��
l2�W�H��j�v5F)���4�!rA$E�A���"Y7�C�U�fI�8��Z0�h�1H�)��_]@V�W�}W1{d��M�td�;������:I��@��-�im�2f�vV"|��d����XHX���R�
��I�P���|N��������	3�0�n�������	
N7�}��IJk�m���;�Nm���J-���0@Y����j�_#�[T�bF�������JdL������.QAV��� ��0!����C\�t�7��9]�wU���OkTA���)�T����G0����ao�b�#��x������	e�Y=��.��w
�z������f�.����<�.���cyhn����1�����P���Q�	$�G�z��NFF�mq� �@Y�,Y "kE�4e`��V���i2<6������:����,���8�#����w'�
2:��
����J�����'�1V��;����*�����i(	os�L)r��,���xffeo[A}����nZ�����p;yk���k���B(���_�>�]�OR�w"D?u9��8!
���o��-?N�PK�*^W]����,4benchdata/pgbench_stats_14_0002_sample_data_1m_7.out��Mo�8���sY )F���{hS�0�uv]�[�HL"��\�j��Q\G��R��#�;���y����^��	�x\��R�OL��&�MYi0����W�]��"��P�&�T��
uU}|����VU���\����vu/k� W����t�C�T��x}��^�U���u)�����5>�f��`H��m���u�����/m�CV*Y8QW����<���|�2�{�@�S���������	?�U3)ui�LA^i-#+W�:��Q'1��&A��si����@���1��
w���aU*U6��L���5R����1�q�?�������-	E�J��O�)��g��Na6�2���x��9��~�n���_���R��E�|���q��8v3�����%~-ov���>�3��j�\����B.�*x�RN6��n��ksv��dG_7����w�����������f����(�U�M��	�<b^���� �)�(�L�M�"�{��I�X��������R��w]@^���n�����Q���@�����,��7]`��JWn�r�;��c�DL��v��e���B�#%/�R�
�������r���U���1q���0�������!L;2phJ�h��
�	�0%�`�G
t1���v���)�	�Q�QWS��������wT��Q�u
;������x�,�PBex&�F����>��l��s�i�t����U����T32�b2?�T���J�����Y�SL��Vt����
�Y���.@�g���oKe|���I�Y{����a���H�.>� l����;��m=A�W�zN���2��������8�G���`rr�/.M���s��4��E���;���Ex(�Y�9g��8=;�&�o���m+�:O���s���{k�b%�����4�^�;�ElJ�:��K��1)o�g^<����nL�5r�G��,d����D=�0��(N#��K�-��AO5��� e	�1���{�C^�|�6[~��PK�*^W��[�*6benchdata/pgbench_stats_14_0007_sample_data_100k_1.out��Mo�8���sY )��D�J��~�����:��Eb
�JT��������j�1���>�y������\��������&�m����`6ky��U��"[��T�6�T��������g'�
Tua�mY�������
���Rj����C����x}Xe/e�U���)�������>�F��pHd��L�
��:�m++�v�Y�d�V��J(�\NTf��7���M�(�O�\$D��vR�������Z�
+�^�����ukR���6�si�������Ikl�����-+��T�l��v_�x��k,�	�l��C
>O���]I{�/���������0���]Y���L�<Jw?f�opo)��au���xD�P������bi�������>�5����\���m���
���W�b��j_�Qyy�.n��<����n�����i��o��������i6���8�	��
�(&q�@�>�6�8^�0���
���sR$<�R��� ���4���{O1���1�wz�>�,
lo�8fW`\|���6��H��(��� X� +g���b������R&$���q���s1��'g`�"�u!L���N�
����
��R6������`L����GL�4�$������{��QWy��c����Hx)N ��rY������`�vK1�!�#�z>�m�/���xS���M���R��~oT1IS�s�@5���Qa
���ifV�;;[z<��j�^�EF��������lV�}}W�������R��������F����K�h���
�)�;���o=vN�����a�j��Q
k��\3|�"�'��-��g�%��	��=��c���;�!E���	�lV�{�jMGy�iq����v�(aD��
�u���!V����e����Xy��$
�����j������~�Z���;b�\7���V�-a��S�����P`��I���v���
�&���L�`2	��������'�
PK+^W'��L�*6benchdata/pgbench_stats_14_0007_sample_data_100k_2.out��Mo�8���sY )���R���0�uv]���HL"��\�j��T��q������w���3����V��
�D\��R�OL��6�MYk0����g����|�-k�I�g���pguusb�����������JNtW���;�U)�i{���yhdV<?�����*p~lJI���ZX�g[�W���g�)��uS��mea����.+�,��p8��s���De��}�o�d�>A(��D@�NJ]�2S��Z�`e���y�K���_9��Eg��y�;�����%+�/��m1X1T�Re+������s�]cM`��A��_����l���i�%_���)��g��La6�6���x��9����n~�����4R�������C�!�<���.��cy�������)�u��.?l�p����X����b��j����[\�3$�Bh����
l#��S��/��������i6!_���;��>@XDA�aD�`�"$LFD��,�}��F?����D�������)�E��,M��d��.�T�4&���Y�+"�:���Y����E��Y9E�&���$q:���c�
�R|�S8Rz�/H����tE�T7�iG���R����tLvASh1�d���0�x��\���'`��bZz��V�5R����gIHr��/���{,\S�<�E��Q�'!���m�O6��2��m��������F���	��GP�H������1���U��%��*�z�=c'��fu'�Ua���|T��mW*3T����N��>��,>�f����CZ;���c�(<N.<:��C�w:�$e��@�)��n�-l}3	��20M;-�����3I��3�!,�]�bvU�{��%�=L+�\�e���e5zw��an����"���;����g�6�[�L�T�2�t��������X7���V��!�������� x�8����j�`d��
��s�c�� f^D/��?f����
PK
+^W�h��*6benchdata/pgbench_stats_14_0007_sample_data_100k_3.out��Mo�8���sY )��'�bmj����{3�IP�+QM��K�q�G���
��������;e�G8q�~+}>�uj�4�Ee�n��
^����Y5���'M���<���U����V�(�����\k51my�j��!��2��t����Vi�r�L���-��c](������]�f�H�>�T�
��*SM�r'�����B�E]
�3�8��Otj��7��Vu���oE0_DP6���H5d�1�XQv*�|/�$v�����������>V�����Ic����l�v��B��QN��}�����v�&�{���/�u�}6�����������r
����S���M������f6�������w���Rp�cu��Y�!�g��NK����eZ~������3���}��W���K$���n����v$������Cb?$�_.n���m�H�IR�+�mn3F)�Zc�M��/X$��B�Q;D'���!�h�QG1�#��c�B���,� �����]W�L�}dI�dp���5���5���\�,��BZgW������jY���]R�dR�8��Z���;'�G8�d�~�aL1'�G1	"F�t;�iG���RR��9�Pn�>��5`<�'�;
c�K��%|�${����*�#�.���Y��\}��L&d���[(�I�T����!�1�����T?��feZ��|�hPy\2!9^��)�T��	��L�����d�bGO��|Vq,F��{BV��^���]�QOz��km��2�X����������t�;1��"�>��M��GX;��c����C�;��,���#P�R,�	��q���������1�A2��������g��Ht�"�u���aZ
9B��+N�u^@��
�:��\�U�����#Xo9�
}j��"�"{B����Vf�8�b�������z
�'������[��#�� "��������w�;n�sz�2�=���{}���l�y�PK+^Wq*���*6benchdata/pgbench_stats_14_0007_sample_data_100k_4.out��Mo�8����,�
CR�)���Fa`����7C��DE������8�9�X��C�8�g��|���xdg2)�Om�G��m��j,s���b/�EeK��;��0���Me�=�������^�+V7%���^=�}}�[����T��n��}�[��/_��sU�5���V��wqul	�m�^�������[�M��N� ����yet����`g�!�:��A�+���m����,�E�E���U�rUnX�X�_�U�Z%�����-;�Up����O�{lz����:G����
@������ /!/[�D���h��/8E�{�������G_E�\����cv;��w;f��������gv3e.o�c��'�����Z�3����g
� ��'������7[O�O������B����>\�"T1�3������v���M�����C� �x>��^�
l"���+��o;D�hz���G(J�;���C"5����-�x��Z%<�O��	#HEa~�������Y��#�2�$�#�����e
�$��+%���BZ�G8+X�`�YyM�.�8�Qvzq�T�>%
��#�"�����1�\�D:����0���-����J%�����@S��8R��dz�)!�x�|)TS$��AL��Y�V���1�5Rn�T�x�N�����J�0��^o��b*�`q��c|bZ�|���|`6��)_u���w�J����<�#��dRI���#}�i�{�*9��XM�S�K
5�����������w��~2��]_w�/��'���k�_W��0>� �����n���8��C�w:�fxD��(-e����d�[��������I$�x�f���)��+�#��t�7/��j�wj���G�N_
�� sl�m$Ry�X�����*�Y�'��o�!�����E���,TYxA��T����#VOM��"�����2�J�^*o�<
R�	�?8���%I�}�0TpO8vr�O��T$����m2�8�PK+^W�����*6benchdata/pgbench_stats_14_0007_sample_data_100k_5.out��]o�J���ss����];��hST!��s(��r�MbiYS{���q���"�����wf����2�3\�(W?���*5u���4`�+uo�Ear��j���Gu���<�#�����G��5,��u�\i52��AUP>B�el���_��J�������X6K���*����a��m����'��&�z
���T]���]�cZh���p!!�_�#�Z�����J��
��b�w%,�Qa
[�����X�*������j�(���t�����ec�'�rT[\r������
��,�.j���e����
�`�����/
�y�u2���~D%�����������0�~�M����lZ=)��'���`+�����r�Y����H����x6����6�����P�M�)���Y����B7t<!h��xS��6�#�xT�ev�o���	�g�����B"vc���Ymr�!JY�[�;�<�0�	��
"?Ds4Ed�l�FL�F��Y�C���=v)��o]AVX���v��.�$q�H��' k��K<'�,
�W���h����,�`KL`5��:Mw�T;"bu�@�����CH���c��������ORP1���>L[2Wp|J��	���.���N���PL�a���L]i�&q�P��;�.�R��H��rc
�G-���e!e��58����J���Mv$
4��M��lJ�K��������+"'��p��M*)���Ag�����[)�U�n�!wY��
�GU-r||W`��^/�B���%#��r��2����P|qrg-���s�����a����(c�"?�N@i8���K��Y``F����4��%�c]��9��b��Gg'�J�'��?s�=F��I�G�6b�t�`b��>V���������eW�X1o�.n�e��b�����(+~��g%�����{)��fi��C���I����D
R�O��� ���#0\�uN�����A#z�x�D����o�&���_PK$+^W8���*6benchdata/pgbench_stats_14_0007_sample_data_100k_6.out��Mo�8���sY )����{��Q�:����P$&@Q�D5��/�1g��1�����hf����2�#���T��>��67]^��1`�+u/�eeJ��:������ue�����
��g��5�M��]U������S-4�P�J�mt����Uy����������g[)������{�u��pH���\�5���P]�J'����y�U�����g����':�.�5��T�?(�"!"&��nR��V���1F����J0����:��3�E2������Moa �|�Y�d������C]i]u��K��)_v����v��,���|�~��?��	,�r3�����|���f�������g�����e���l�
�l��y����E$Y,�<����,���z������)tM�
.?l�p��a9���L����
e$R��zs���8�I������
��1���|e��6c���7�]{�B���tB���X�J	aD���$i{��:�Y&R�������@t
Ee�_�lf���e)���l��,�,N�
�"0�d��r������*������]Rq�z�tR=&,���'�G8E����������h� L���#s
�O���������1ESH��t�1�d�x�|���b<��V5m�e���1R���T�@ru
��g!D�bZx��J���AA��q�(z">��l��S��������?
���������L*�s�}0��`T�d]�"���9
2JO����YwCV��]���]�QOz���+m��2�,��H;��fh~�,8���\������fH�7��H:��0B���(������#P�2
Y��6�9�In�%��Li�����MkN�D������A���jO���yZ{'�b��N���T��������A�<��-�,�.��0�h��+yh<�J^�����l�w�5D�YF�1G��f�Q\��S��1��8����x'b�k1i�A&�������}��8�
PK,+^W�"�x�*6benchdata/pgbench_stats_14_0007_sample_data_100k_7.out���O�0���W��$����;L{�X5U���ioUHDr�.q��wm)��$k�@E�������c�p'u�g".�_��G��t����5��R^�F�(u!�e��?j���*����n�@��t�YAU�o�j��Hw��l���\�R�v��?4������*{.����M)�~_WK|��z~���L�,�:�m+_����T�p����g��w�#���
����$|�����QU;*ui�LA^k-_���Z%��k�Y��+g"��4����<������Qkp�
�����*�*[�����M�]��F��`�I
��<�:�~�%!���z6�4��t��v����o���n�`��A��5�~�;�H	g����"����n����x6����.����och���%\��.��r_�aR�l��j_��#�{�����G����+��n��k�
]1\��mn=D)�;m��E�KY�r7���
� d~��\D�`��X���@qW=)�}W�@�s�D���z�S��,�Y"N7�zMXmN����G[��",?$�
y����u��$E�{��#Hu.(?`q:����$B�o��gc
�T'�tS@�:�T��iG���Rq���tL���)���]L�s1��v����'�AL1q5=z��V�k��Eyq����#��lB$,��;8[��.���<o��xD�9�'���@o��S�j�S
������&�b9�jF:���L��K3��JP EW��MO��5v��P�������w
Z>����+��;�g�O����58�+��1hF� '��5���E�����!L�:���X�t�I�(O���,�����q�^���Ai���k�1���N��v���\���`<2�>�R��8b:�c	���:�����gI@\q+�-$_�Y!Y�q������Y	����a�T7���V���=�c��>b���,
���������h�`�������d������}2�0�PK�+^W+���+4benchdata/pgbench_stats_14_0007_sample_data_1m_1.out��[o�:����r�vU��s��<�����sX*�7�&n�q����o�C)`$��
h����yn]>�K�?���K���i2�f�)k
f��7��X���/����j���*�#<��nn��~v�YAU�o�j��Hw��l�~�\�R�v��?4O�����U�RV]��M)�~����l���>~v�R+X6u.�V(���Y�d�X���1�������W���M�(�o���}��!T����)3y��|#VVk�� YK���?��X���si���@����5�f�����
�P�J��Dy������!�`�bg�/��y�m2�hK�8v%_f�O�1�M'���a2�:���x��)��y��~L����4R���r���<��S��d�c<����v�i���?ch���%\�,��z�C�����3ov���s"�������b�E�8����_�6;t<�x�����������6�jO(����N �)�0
���Kt�CF�w
,FD0/D=)QR��w]A^|W����=2�1���x?
�z�=0�����w���s&�&����h��	��!XAJ�:��^VV�%%"/�� �lP<
� $���`�S���0dc��)��a����cUJ�a�����L���)��2r�.&����H�0�R��G��b�DLSo��j�F�7+�E�'�,�v����x|X-rkgJ���vn�1��&g�����p�d�)S���]�N)�O�*����O5#�
���K3;(UI��h�JFWD��C���2T�d�(���@�g�Z�w�2=y���	�����`w� ��`�Z��H�=G�7&g�!%�����;e$8z��R�,��~"z2eP��{���"�9��g��!�F����,��KS��?��j�N�zQH��i
�#�-��wp���b��I���:��-8�U��2��	�H��(�wb���y���"��F�����00T����5y���	�9��[���s���E���(���������V.����$M=�o���?�~PK�+^W(����+4benchdata/pgbench_stats_14_0007_sample_data_1m_2.out��Mo�8���sY )���S���Fa`����7C��DE����~Gq��H���
�/���y�������#��(���:wL��&�LQi0��������|����TN����p������le����Q��FIG�������LR�����c-���a�>e[�����T����
>�E�oL��m��6u����9�/����P2�F]
�3�2��:wTjp�[H�:}��	B�c�y!��S������Z�+�N�]�Nb6
~�x<����
�X�F��;��9K��&G(��P�h$�s���_�������������������P���\/g�W3�]�����|�u��E�70i� 
���/�������
��}d�����oG�/~��+�X��#�>�{M�������>\������%�g9���_��#�	[�uy����[�Z�.�;��b��WV��z�RV������Dn���9�����$r9
d#���qd0"j_�� �)H~B��,S�At
Ya�]U]Q1=2������G �����0�]�����WB~����������9X��QV��K*N�8&�8�T;��f�B;
1�D�4��wc�m�tN�RbaR��=�x�J	�%n��P8�Scu�����Z��lg�i(E�	���)LA@���:�Tw����<��j��e���H\FK������b�wa������������)UO��Y�V)�O�-T1�Z���=%�*O���M3=,U��(�btw,�x�^4�];��bu/�u��w
Z>����-��%f���n
��1�X9&�G�LK��R�L�����	zV���2���|Jm��^gl>�eP���7b�]�O���T<=��,�]������$��i���$��i
�<���~�]A�1��1V�����
����(�i���dCv`Sb=+��R���G�vz�y��&$���������
AO�{x�����)pE���#����6��--������Gz��8��o���>:�PKV,^WO���+4benchdata/pgbench_stats_14_0007_sample_data_1m_3.out��Ko�8���sY )�=�{��(l���
�f(��$W����/�9�T{}�`�?���3��<��*{�3�����3��U�f��+0�������r��Z����6KuQ=��������N5[(������h5���N5P�C�U���
/�c����e�>eW��gS(��jac���^��g�j��MSg�mUn����>-��=�+�pF	�����N����_�I�	���PI�lgEU�"���U�^�e/c$	Y/1�����X���
�XwFL�g��k�vc�[�r�b(��VYyn7V�/�w��4���Fc>����b����a�K���?��p�\�s;�����_�����`��A���X~�;�(g���g����2�=/�?�7+�X]�=�>}�km�5�����>\�E(� Q$}?7�]TCl���������cb"�������.B��d�����w5E)���4��P$$�(�#UQ(c����:�6�;q!u�	c(G� 2���,��At
Ya�����bd�1N��r�~�
\�Pr���Z��$wpy���?@�:
��e����$'����#Hu.(�$G�Q�!N��yj��\L��RvS<Ux���'s
�u).���1:�#0�L2��.@��t�����J{L8A�0�x/���Y��k$�,�7C�v
��[[�M��pP[o�(y��_dF�������N��t�7��)���������6��6*~z^��S�B��l2�R��8��)�U���?)�|;�L5�{��s{|P�'�]�u�6#u��]-B�p�>�f	8�������N���im��8�ix�V�G�	z^���2��$��(+���4"14e`�,A���f�+v��D�Q*����`Jj�A�� fWu�$$7V�{(���VW*��T�brh������X�
���1g�:�[�����Y�y����7�qV����<VOu��,m�����((�c�������q$��W����8�����E�$AcL��@1��������PK�,^W(��+4benchdata/pgbench_stats_14_0007_sample_data_1m_4.out��]O�:���+��H�B�N�8a��Q�*�-�t�t�PHDr�n�,���	�4v��n/����O�����2�#�1���J�Ol��&�lQ������mar������&Kua�uU}l��U��*G}S�+�&�-�T
�=d�P�6�n��>�*�_��sQ�%��X����j`��6Y� �w�j��U]e�iT�����>-����+�pF	�����N-�}
�oU�
>A�Y�#(�Ia
[����J�(;#Aw�j�W����	�=��j-��O�k��1�,�Pe�u�(���1�����i�%����P�/������D$�+���~^N�f>��f
������3\������p�s6�w�V
�z����Y&D&��<���.�����fZ~������3�6}�|�0(�a��YL7U�jsv�������gH&^���f������{;ze��m�(eUkl����	o�#QD;7y/�Ed����g�#O�9���~#���HY��At
Ya�����bw�D���#���
c�H$�"]`����-��J!�G���������AV��;D*`�0��� ��A
c��x�����~���<���+�$��&�a����CS*� ��>�p��8I������[���a�KS1W:���aB��f�����5*�R�(�n���������+y���B�&�
�6�� ���{�������#�)�O���5��8��TQ�gu�:�j�M*�boR�4��Q5<�]1��5>aV���b�������W�m����z������v�/Y IH=������x�"LP7��#��LG���������:��s�w2��
���L��d!��Q��-c�pC�f Ot\z�=+�����L���?2�sv�������g�N���s�K<�<96��}���-���~�=��S��-�Y��q�Vvs������x#p����nl�6j�S*� �]���D;
�,a��r��[��/��@6r�k�J"#�?�?~��'�PK -^W�_GR�+4benchdata/pgbench_stats_14_0007_sample_data_1m_5.out��_O�<���)|�J0!c;�?�]l��*�+{K���*$"9I�8�~��PJ|����������9����V��9�a�~)}:3uR6Ij��$f�U�Y���L=��6?��I����tU}A��g��)��M^l���mq�jR��T��4M����Z%���"y��� ��\��~]
���}��
���M���m]��iT�s[~��Zeh�a��Q��?�3����$�T��+��<�#1)�Y^�&O4I��T/����q�Ga'1�~�z<,"'��y�ZC���s�1��8����y�@�����y�m
�f��b�3F�|�2��X~�%�/��r5���������9Y,���'m�=��%1I}���^,��[S+EN,X���<�W^,���5��������;'M���"��}8]�'|�s��j�_U�6�#!B�����1$�b��������_!3���}�r�RZ���w=!H��� T���XR/d�FT�e�3�j�1���
�A�#��4�@tF���O]u�bzd����x:�n��XL�d�#0.��,\H+
V`�(,��E��AVV��K�K*��>�Tk�"Rr���N����9���1y�{>��b��*&�a:�9#����$�N4=�`BS����I�h;<v��0�R�/�7
d��Q7i��c${�������Zvo<��k{(6w�����A�mQ0��7���H6%�1�5������AZ�u��I*_
*#��`����r�����Y��_���x�3pC�;Uo2���H��ns����%
��tWvk�OF�Q���#��L����EX;�a1�:��C���2�1����K��{�"p���2\��=;�K�%�V�&�2��t'�3?�i�O?;aV��d����)ZN` �!�qwy������{��8�UD}7p�`�����w������Y���K
�����V������&���^z9b���z
\D��c���8l�������rCL8T�	zy���b�q�PK�-^W�!���+4benchdata/pgbench_stats_14_0007_sample_data_1m_6.out���n�:��z��\ )�����65
����tg(��(W����;��H�-E�1�������P�#��0��<wt��:Iu^*������:W�x5�I�N���G]Y]
s~5��BQf���b#����NTP�C*s�t������I���H���)���*�����
>�E�>$��&�r��LE]���}�}�K�����%����h\����J|����7����\�:O$��R��X^�2F"�����'�c~��p������00���5�Y��`79r@1��y-P���T��zS!$�J���P�/�o������]Sr��}^��v1��v����Oh��n���Ah��1_|�;]	
g=X���,��� 4#�?f�~�n��V���;��l�T����D.�2�,&��q��]V]n��\����������Mh��]\�v��������Vc���Q��v�<����f�	�����)	)3�����Y��z�,��I�Z��3+�
)M�;�. �5��e[Tt��e��OG���
c����V�&0an<����eh=J�(,ny���������x��c��
w>",�,o>���;�����HY+�����.�l�0��\��*�b�"Ax��p��(�r�[	��dcbb�v��,
#sK:��p�Mh�uZ���^Gq���t�X=n�)G�{g�m�Y��a��������[3|������d[�U#%��w�dj��&V��)�
�(���TY�Q4�<>4�x���U���e�X��j���]�Or��kr��%c��BO�����}����aL|8��g�{�-��v����>�lF��;�Xj����R�,w)���`��8�9|��M����x�a�;�Owb������(�8k���.	�Q^ZM��������G��x�yC����g��w���n�~Y��5�5|�����S��e8�g<�U����!x&��9�S&,�-PG����8}�yg���a�������R=����������PK�-^W%����+4benchdata/pgbench_stats_14_0007_sample_data_1m_7.out���n�8��~��,�CJ"%��C������:��Eb
��JT����$��#�^bX�gH~�C��om�?��������o���r_����������
�d[��t�6�\Y�������gg�5,��m�\9;����m��������F�{���/��S�����gSZ�������f=�pH��]��VM����������t� Q� �D
)���y\��_���-�	Fj��DX���*}�9����/���F�D�����Z�����A'���;������K\lG(�e�\�Z����x�z� �	�>R(���_��f�O}���\\M?/�p=��s=�����_���	.�����z��1��[�X'=X���U��0�
>���^-�cq��i���_Sh���-�}����m���B'!�s5��j77�� d��W���XS���z~�
��!��J*~a��]�Q�����zG(��0:�� TqD:5"��*(�jo�*a
=FLB���� ���&�����G�K�]�1�C� �h��m��
S�2������0�n</�.���PK=
K�
 ��AV�C�.�8�W�Qhp�l���c�������c
E��F�a�&&�\7����Gx���06"A_&����0%��H��br��S_�G��#������w��n�F��(��@�)+��s���	��Y{g�-�zR:z��	��	=m�3���xS��u{Su��?����A�`}��s*-CaB�@J3�V��a�T��&�x7B��
e���lsS��}��>���mW:?p.�����o3�~g����#Q|����{���>J�Qx�RB�#�H����Dc��>eEY�0LD��[�L����JS�at{]���������$i|�%����%B����W��d���Iu �c���������Wp=Vq*}<+vN�ih3��U���B*��U���8�
�n��a�X7����nC�:l~�����D;
*|�;-i2J�-�N<����`o��[��(��7�����g�O��PKk^W��
F�+8benchdata/pgbench_stats_14_master_sample_data_100k_1.out���n�:��~��H���D]S�E����9�u��3�IP�+QM����8���b���r>����;��G8������|��L5Y�E�@o��
^+�
������&��PpotU}��W��
�Ua��(��OT[���{���J7�n�R?�<+^^���(��?k�]�~_
�����+`}"�l3)7����7
/�����gB�Y]
�3J(��'2�&�
d�y�=p�<?�S�2
e3Jh�I�+��+1Q����N����i��1
|8{��j5���Om�,M`�]�p0b(����F^��T����6�&���U��
�e�m6�dKB/������r
����S���N��V�p3��\��������s8�`��y���D��g�����<�7;O��_�O���:�p�q�������0��t����PD>������>1s��������!��g����(�U�t����D�b'R�B����#R������Q3Jb7G� ��9.)��;�. �|��k*�B����a�' ����y4 ^�c7��@1y����i�����zV�8b��ee�1R^� L��H����tT�p�J���K���DX�0������RI��	�LfAT�1�������l��D��������+���bg�<����O `�B���$���=��7S���{�q#��wClM=�n�F6��2��m��j�4���F�R�{�U�v*�H�8��if���QE,�Cs�#�+��P��P�����0�w
�?����R��e���1r�nva�4LFc�T��EiM�E��F�zX���P��G�v����@�,���TT0S���%��c�
����L����p:��Y�N���;��i���bNo�{V�yw�[;p6��\��7:�NI��K��Y�Sz(�+/t�b��r�����g
5	b��U�sdQ0��#a4x�z�C��Y?�#���]��	�XS,����c��4�PK�^WG����+8benchdata/pgbench_stats_14_master_sample_data_100k_2.out��KO�H���uY	F�t�3��<�Q����io����ng��@���	!]�I6��Uu�\����2�#���P��>��&3m���6`7ku/�Ui
��Z���'m���<�=���
��g��
Tu�����ZMLW���{�u��m{���}lTV�<�����*p�������ja���^� �w�i��uS��mU��KW~��Z��
�	O���Dg�����j����4���������e�!��Q����E�"�%v��O��L�0����>���
��Ik1f��mp��b�J��V��������]��&��`�4��G|�}�/>��0�������r���?�3�/�����,��z
6k�����7���Rp��:�,#�K|��1�Y���z�i���_3h���\~��p�?��x�P?7����g#7�iB�_o���)����v���=!G1����6c���3��8�d��A� 
D�nA�CFaD
FL�^	��Jv))��o]@^Z�����X�/#O
�r�@��t�I!����
�W"���E���E�����!��AVN��GJ����)u}���� �R^���'�(n�QL�
&�����0��\��]j*�E����0��)�zQ4�Iw�>�+�1%L:�)����[����H��
$��:�����V���Q�)+2��h��c�G^�n3�G2��O6��2��m��������F�^�?�*��
{o�g����)��P�bt��Q9Z�|Tz7��fu��U����z���]Wj;T��������?�����4�����F�X�q|��pP�tu�GR�t�)�����h8�i��bth���p*N�����e�xz&:�0k�����Q��D�r�ZCi��$�h���<�y�C��bu�[;p.���-���)�����<�X����JK�aV��cy�T7���V�������(����#�B���4`E@)������~���v�	f�<X*���/?N�PK�^W�Vf��+8benchdata/pgbench_stats_14_master_sample_data_100k_3.out��Mo�8���sY )F$��b�0
[g�u����$(���&����8��mU�!��w���w�������'��Q�~)}91MZ�if���Y�xU��*W/�e�O=i�T�#<X]�����T������-��V��+�U�d�P�i{��K���4��L_��+��gS(�������n���)�}�R�7�n�L�������?��V9��
.<�y�_��{�
��T�>*��C�<C�N��0E�!��J�+�W�2�%f���6_'�����<��������5K{0�.n9X1���E��<�����w��4�����H��<���o��GW���|YL?-�p7��w7��������n�`��Q��1��{�(����<�,�b�y6�1],���v�i���?Sh���\�.��z�C0��8�b���~o�D<J������Sbs,^.��_z�bq@2������(euW�f��v�a?�Pu���C�#�p��Y�X=)�<,F��L�
�d��u�7� <d�<Y���{��h�S6�J<,wp!�������`�!����d��1R�L��#Hu��	N,O��p
�Q��s1�L��	zJ�� L�;�iG�
�w�X2Oz8�LvAS�$8�����\i�&�D�K�x/7�*�u���(����Fqs����vIR��J��i*���`IB�<\mC|������t���Nk�����d�����/������������/��*�g�~�ON��;�5���r����R�z���
mN�e����lm�~�E��
���2IWr�!m_����I"���=d��Q&���j�������{8�2`F��C��g����M�x�b��S!q�bvU�=a3������SB�C��� +���8��Co����&���J��Kf�,�[�L=�F�B�x0�?��X=�Mk��Uo!���>���8�{"�B��d!]Sx�C0�`G"����Q����#��������oPK�^W�(���+8benchdata/pgbench_stats_14_master_sample_data_100k_4.out��Mo�H��������"����h��FH;d�!���cwKm�������B�*��(�������:��{UeOp�F������4i���)�
�f�n�U�*�\���i�I�����
uus��g��
�u���(�ZM���W
���BU��u����Qi���L_��+���)������m���7$��.�z���T������!-��I�
������N
�}�/���
�W��p� ���Ua�TCVW�z#V��2G�~/1���|Q�H.��TwB/'��5K<lG(����h�s<X��n�k�v/\%	a����f��������b�i9������)��_��BW�/p;�6���������F)��`]�gv�P�y6�1],�cy�������)�u�d
�?l�p���O�g1��j�7r"�������!�'�x����
lwH�������6w5F)���4��'��c��@�:@�GN�2�Qu����b���GH��� �!���e�7�� +���o*�B&��Ib�f?
Y�����
MC�a�
[�h������qX���������;F�
���O �P���YX�1N�O�v�������$�<��!L;2Wp�K�����
������aL�PL���Bf�-ELI�N>�)�X^^z�����wQ��������Hm�����C�a��j�9�q>c6JGzS���M��:��?��Qy	��k�@5��

 $�Bi���O]�"c��c�-��y��3xCkV�Y���]A���fu���e��98�.�=���b�`
����A��E�h�zR�:�����0B�X�|�	���>
e�Y�1Z���e�����NS��]�cs����w�E]����N\��N�K��{���P��}���JG����!V�����Yx)��XV���u�{���f!�"�rOg�:�;���nZ���z��$B���_�{"�B�����4��G`H~��`����8�R�yh6^k�����'�
PK�^W�`oZ�+8benchdata/pgbench_stats_14_master_sample_data_100k_5.out��Ko�H��|�����"��7�ah��Cv"�
9v'��n3v{���!��;0@�Uw��^������B���%�����n����^��(�����l���5Y�
���������PV9���\)9�my/k� S����t�����i�yX�/E��`�X����j`���^o���g�*��U]e�id��k[��J���\�p�u����������u�(�o^
'L|(�Q�S�
�Jk�J�(72���NbV
~E��
\<��j
��^��k�x0�.�Pe�T�H��x0�o���i��2���'�����$*�2�|ZL�n6��n�������������4p�c:����.,X�o�B1�<��������yZ|������3	��}������$S?��vW���y[�����>��T�����t�;��c��������U�6��"��N���	��
� v<�9�����E�,FL��/"���	HY��AtYa�]U]Q12O�N���	��5-`�N�k�������z��j�a���h�ee%�1R"
�X�#�@�%���8bd��8�����1yX����J<��a�����U*���*�����r0�TK1q�&[��$�-b�����2�T�F���/����Er�K0Y\�� ��LY��K�Iv�����
���I	�t�6��9]7K�*����B�c��Y�:�j�+�I��<�4��R�_���KB�W��*a�	=��P�z��2���-��zy����e��E���n�3vK	�-Xf��#�.5����p���=z��� ��rsJ�Y&1N���l�8��Nh�&���R� �`�m}~$Z����-�@W%�S8q�N�QZa��jK7�X0
�,z�qw[;p6��s��O`������b��e���Da���@���O�x��sU7&K�j�.����o�,
�@g�?8F������E7��J����P�n��.>�~PK�^W�<9H�+8benchdata/pgbench_stats_14_master_sample_data_100k_6.out��Mo�8���sY )F��S��Fa`����7���DE����~�v�cK���q�r�3��������O
�K���i�nEn�Z�Y��
l�R�U����&m.T���uus��g'�5Tu����VJNtW=��G�U)�i7��������~X����*�������ja�����@�'��N(��US��me��k[�(J%'�<����y\N�0X��/��'	���4f^��j'�.M)�����XYme���j�W������/�y�;=�����������*�*[������]��&��)Y���y�m6�hK�8v%_���S�������l�u�/te�
�s0�y�������4R����=�,�����������L�O���B[wM.���������q?s��Mw�:�����HE_�n������~�e`wCG�#������C�����Y[��DJ*AH!
e���E����`1"j����F�+v ���
�+�K�?U�*�B�����f�ls���8���M��WB�.G����!X
%���zYYMw��g�����)�Y>Kc������j��\L�O�t�S���T��iO�
NO���]�70hc�R��p��\L1)��dK7n������i�-�Zm#�>*�������N5����z�=�4Y�L:�|��
�����#f�P/b�.u�����M�D��#�
:�x�����.�GU
:�"�l��A���
ehX=�fY��wZ�����+����8D������3�8���F�
��;8�mk�3���k��#w��c��QfKR�={JMY�)K��!��`&����J3�����F��D�X�_-�?��j�
8.Y��k4����VG�� +�U�����g��Y�?�|��!.��$���m����,���B��;�^��5�h�[H�U�v���'�(D~��l�����nR���0�� �������}��8�PK�^WQU��+8benchdata/pgbench_stats_14_master_sample_data_100k_7.out���n�:��z��\ )���Rt��Fa���u��Eb
�JT�});��q�J�"��3���3#j�x�e�g,��/.�U��I3UT�v��`�X2�/�!�O�4Y*
�ZW�W���-��PV��7E���my�k� ���t�����i��X�/E��`��.8��j`����^��'��m*�6u�����_����<�����%����*��-��x�>r��������q
Y�"�UR�WbE�����Dm�S��b��p�\���U�z�4J�Y���~q�A��,�(������w�������C	�
?����|�����%���������f0_|��m����TZ?rw���7�W5�pf�:����~dg�/ng���Z�2�>�wM������>\+t#��������:�f��%�������'�(��w����BK����WV��r�RV�R�[���H� �#�D~�Q"���"�0!���e�zR�=gA�2�D�J�U7T���e1I����5
`��$��7m`:���=�,����m� �������2��=R,I���z�V�����9j>�	�l=�K"���!L�?�)��a:�����T����#0�MLABB���$��v2��M���&?B�q���Jt������D��Q#�����\�����zE3	
1���	�6��)|bj�->��lJ�s�m��B��?��q��#��xR�>q�0=Uq���	�)M�5��'��a���u�o�H�,������/C������j���8�����#F0K�kM����}t�gYo:����'1�8&q08��	L�.���i�������8��1�#
>� �W5y�A���S���z��Li��)�V?A{A��cu��8�U@<:+����D��bo!V�V[��F\���Y1�V6������

�/�7���KdP�W�m
oq��������r�L�O���o���>:�
PKW^W��\�,6benchdata/pgbench_stats_14_master_sample_data_1m_1.out��Ko�8���sY )��L��>�����u`o�"1��r%������8&'�j�,�g8�q���*S<��HJ�K���mr����jv�QW��XU�TO�e�O=i�\W��PW7W &?;�la]��o��F��������
])c�^wxi���/��S������T��q���w;�W �D��r���i�B��*Q|����J����g�q��8��������RM~��O���EA�vR��V���6F� ���:�����M�?{�q,�=V���,��OZ���qg�[A����U�P^��L�{� �	�?�	���
>O���]IJ_�e1�����|���f������'�����{e���l�
nm��9����E�r����<���.��X^�=-?}�k
m�5�����>\�F(E���D����:�����]\�=$�!!�\����v��3��_X�|�1JE��l��@�,<����� cqB��7���
FD-3f���F�/� ��
�(*������= d�;M��#��k��P�,�H������")��r�Q&YD]����/�`u����{�T #�R�
B����B��r"����#���1��qL���IwC��d.��.��d2"!�	t0�I���}/>&��}��Sw0��0d���1L����VE��1R�X��C�������V�,"9��5�������LY�Rm��1�O>��r��o��������F,?A���9�T�YB��4�����w(�b��$���N*��g��2���T�*��.��G�]�v��uD��9�#��18���d�<��G2���i���t(����T4#���;e"r��#P����2����2(��OM_�E,8�����i���x���R�4"�AWug'�,�e���\)f^p_:������!Vosk�a�`����V�N����x�Y�y���t
�L�~��z���y�v&�L��'��}����B,d*��H��^�|�&��x�����$%�d
 z����}��8�PKK^W&����,6benchdata/pgbench_stats_14_master_sample_data_1m_2.out��Mo�8���sY )�IQJ�C������:��Eb
��������q�cK��C���������;]��p�T�is>i��l������Z_��b���~�
i~�I�&&/�����
��g��
Uf�M^����]q�k��!5�.�f�����N���E��]
��u����Wk�l��
����w�1X�U��FgV|���������
g�PJ�:����g�@�K����O�d ��X	(�I^�m�H�������EGxl%����n��>9{����ka �|��v���v�[VEnL�h+�����e�]m)M��E	b�_����l�����������r
�����S���N��.���fmR?�n��������3���[fA�D�g�����-o�2-?�{
M�������>\�����
b1�����w� ������!1g�/���-����e~e��]�QJ��l�MOHRF�B�A���BFIp?����;6�Q�������70I(��=Hij~�����M��*m�,���(��G ���c�ED�Q`6�����1a\��QX���{u� +���b*&���:��T�7*>�S@�q��s���X��)��z�L7�����R�P�Hy:&���)R�6Z�A��|L�}�^�B�c�/�$�1L����2�k${����$���i7�[[J(����W[����h�����BGm!3{|������d������~���IE�ZGPMP�R"�o=>����{+��*
�/uCb�^k'��fu��Uf��(��������u�!	%Z�~�=8�i,��>>�=��z����*>��I6f�r��g��Q*��	d�#P�>K�mas�^���a
r�L�JD~��%�����;��B��R?������G����C�Ct=�9e��{�#����X�{�
��JF����!��S�c!�7<��*�����w�aV�����c�T�M�&���HA����}�=QO!d<��F��y��a��Y��	UG�����x�����}��8�PK;^W"�CH�,6benchdata/pgbench_stats_14_master_sample_data_1m_3.out���o�8���+���vU�v'NW��?�
����T�7�&n�$l�l�CY��@��;c���o������'�I�is9�MV�Yn���^�xU,���/�e�O3j����#<��nn@�~v�Y��.P�������[����M�+�nt�����Y�zq����n	��M�}�~_-���6�
��D��e��a���n[]����?d����
�q�����������M���O�+���,�QY����uU��������(�H������q$p�\����p"�r�Z\t�'�����,�)[��OV�{��4���3��_����d����PR�����|w��?wc�L�����,^�v
6k�����7����p����e�L���f�L�gs����2�?}�km�5�����>\��0������������(�8����}J
��|v7��
��!�g��]�Q�����zOH
��0���|D1&�	��(����By'qy�H0��T�)J9Hyn�Atyi���W�{dA(%K����{`"
$�2�i(0������\D�,����%���	��$+�����@���8�T���(T�%�5����\)��J�h�(����Na����c.H��p�z&\���T�����t^9yj�+�8��W ������z��6��H�;
;J��{Q����J��E�W��J�G�6�� ��T�aMRp*&|�o��s�nUg��{F%S�b���
T3���8d*�����|�
8�z�"cu��K�K/����8�����n��+���Y/����}���?������2A�	{��L�h��B��kok&}F_��#�w6�$�L��F��(KF8������2az���&���<����{���J�fq����i�
�pU��)�wj��?N�����)l/���k^��buX[;p�U�?�{}�����*�����h������_���nZ�g������bRr2��o��b$!K�A�Rx��0b��G"�~�?N�b������������PK0^W�|1�,6benchdata/pgbench_stats_14_master_sample_data_1m_4.out���n�:��~��\ )��H����M����s�����$h���&~���8&��j�����g����VW�������9�&��,�e]�]-�<+n���O�e�/3j����=���n.@�~u�Y��.P�������[���;�M�+��u�����Y��p�=��n
��M��~7���l���>~v�1+X6u��V(>w�wYit�E]��8����Lfq�+�~�&���	�
d2HX���*m�����/�����<ZK�������R)�<����,����Z��.pe�A��1e�Q^����y�]��F�}q&x��2�6�~t%J���r6�<��t���&�������\M�f���p�c2����NZ���"MR���<�����1��f������kr
�6}8�a(���g6��j77oEA$}����}�0$�������f�~��d~a��]
Q�����jGH����~��"�B4W@����e�D�
#��
���� )N������/�� /-��z�U�Y �dB
?�
��c��	�R�D�O���Y�����4a	���au����{�T�q�l�
�:H2%?)>��H�Q��s��� :����x�L��iK���R�����O}&����)S� &��v�[�`r�R0����F��k�>F���P)����>��rk+��r���S	���A�'�A�6R�yx|������l��T�1�����T����UF:U,���4��V��O?_�v�8�]��^����P����M��w�~4����4��.�4e<:�l\��)L,��Fzd�=O������pi���y�;e&xzK���Y�PI�Z#�
S$���J3�A+�����N�]�"$�w�@Gu�N�%�4V�=rv��r������gg���������P�
�V�N�zGI'��"���Z����[?+�-i��c��6�Z�	�N���:��|M��!�������8�g��0����w��1<f�"�/����?��PK,^W�:���,6benchdata/pgbench_stats_14_master_sample_data_1m_5.out���n�:��~��H�@!E����65
�s��wg(��(W����;�c[CG�/,X>�gg�x/u�g<����G�Jt��&/5��R^�Z��u&_d�����N��Gx@]Y]
�nd����P_��R��n�{YA����6u���4O�L���"y������U.m�~]5,��&��>>�D�,�2�u-3_v�I�dFF]
�3�0�>��Tbp�+H��*y��p?dA������:7y� -�����b�s�k%fY��6` ���s�T6z���j���3��� PE�T^K�g�3����THi�s�������L�_���yTr=���n:��n���������L�$��4pw;���{SI	gZ���.�����F�Lo��9>�7�H���~��.�*�p�y3����
���"g6��j�6�#��������>��8�gw���f�D,\�+�Ml=D)-m���������B�Fx����("}�(�gD����P�����qHi��At
in�[����=2�g��cF����s�{X��}�����u�\D��NZi?����jzYu��-R�GN0�RMx>f��s��lN������$�?)�,��j�0m�\��.��N �8N��34Z��(&�PL�?����k-o��a�D]��j���u�|��:�#tcuk+�B'tc���vC)��������B�(��d�������n�Bz���TCk7GPM,�
���:J39�*�r����*�N���VdB�`�2dV�Zdx|���Z-��\���!v��F�����S�~8q�h�GX����D���F�}<O�#�w2�(����)K�M���Y�C����&��t{��BfTl�����i�b���G�����-Y��s����+�����V�6"+��X����U��Xhbi��x���&��,��#�EXE����Y�������j�&�����������]�=��c���1�q���7F�������	��0����_����_PK"^W����,6benchdata/pgbench_stats_14_master_sample_data_1m_6.out��Mo�8���sY )��%��C?�����u`o�"1�Zr%���}Gqlk&�j���;C��;�������#��87��=��:-�4sEU�����(n�27�����v�d�-��G]U_���lM��U���)Vkk&e��35T�������t�/�cm����U�\����Y���j`��m�^A0$��6�v���L����}�}ZX���+p&<!�_��:<��_�N�
2
d�=�hX5��,\�Z���4���U�=G�����%T�����p�U�` �|�8\t�'�����*�-��OV�/{ok�4��Kx�������f��}I�%�|YL?-�p3��w3�����h��������8��1��;Wg=Z������E3��?��%�-�w���>�3��j������B.�;|�Ea@�,��]�FN�+v������A������K`�C*���_Yms�c���-]���*DO��	��
b<EDQD�[F��������T=	+��	�,�@t
Y���������H(/���G ��<��
�$�i
#(.�,��E�����=�QX>X� �^��G�+��v��
B�l�/>�I&������zAxB��:�b���C�vd.��.K�s��p�&-|�l��m)&���a�K��b��c��)/�����5��F*��"��#�s�k+���-ojk�z��q���	
}Ok��h��LL��#�)�O���-[k�?��Q�X{:>��R���$�t�:���V%�}����^��mG���^�pBkV������]@i�����-��� �nqAW;�_��^aF�OIf*�#��=�bi��)�b$���#���NF�E��[��%e)���`�bS�)�pAS12�1T<J��/���;�7���K��S���;�����{��TM�G�V&��m0vw����v��b���=�`��4�������52g_a���	�YI��|�T�����lC�P&�1,����((%�'�f)�}���WI�;F,b�����s���l�q�PK^W�0���,6benchdata/pgbench_stats_14_master_sample_data_1m_7.out��Ko�8���sY )��L�CFa`����7C��D%����~Gql��X������������UU�g"��o��'�I�6�LQW`6ku��UQ��I����'m�����;������N5(��mQ���T]y��� ���L���C����a�>eW����PT���5>�z�yL��]���M���U9�/m�]Zh�;VW���3��_�������I�|D<,�vRT�)R
Y]U�YQ>�X$�^b�-���2���0ug�����5xh�7����PZ�By�7�����)M`��L��e�}6�hK�(p%_���)��g��La6�6��"��9���Wn~�����4J��E�|�����%
�<���.�����yZ~�����k2��}��G(��x��~�mT���yQ���-��9&�#��������6BG,}����j�RVw�i6{B"��}��7�PE�~�����\D�kF�X����1�H�C���w e�~�d�������9 ���Js��@��y&�(b��)�pqyDn�����QK�?+"��������-R�KXB�8�Tg�?H���'��rI�������S^D^� &�T��Iw�0��\��]*�B��k�0%B������;��tF�-�%�h5
b��.��VY��1��X�
p���m_vmEX�1���jkoJzR���E���/X������T?��vUuZcz�Q�}���e��t*��,I�.���*��~���XL�� �`�
n(C��N5�_�T�QoV�]�����A�b��6�_�U�
&c������ta��9Z,�����Ir���='�NF'��q��G��\���[��"V��I'��d�b�+4vQW<H�������xX�"�1/>��j�N3.��=�zd�8��4=�&�0����h����8�U �H0#X�u�HRx4�+�����'�$N����
��c��&K[�5	����+��*{G
�H8v��
��90dx|n�aDL���#�BH���?f����
PK0^W,��zbench_indexes.sh�TKO�@��W�,K$��R)4i������e�����k�@������v����xfvf��w1����������tC���c��g���&�D%:��z����6cS����J�
�{|[�L�:QLp����.���N=o�����`;�`��~0�IaR�/�'�P�T�L!��XF���@�:opy	n?�G�����R�a�gq�H�L��L&S�<q��d{^]�X����|Wy��TIQ�����wCF��JH��T��q��)r��UR+�sxfj��c]�f
��pZ��0�k�T�����3�Vc�
I�4R��UAc�����n�t8
G����������Z�
R��������f��ob�I%��7O�b��Q�J`����PT�$���w��P�`��m�ny3�������)���r���zqU���.G6utqQ�<-)�~w��e�����f$H�S������
`m���m/��d�����MlF����v%�oux
��pA�������wS�R����e��#�^�nr/W7�����u�H��-JF�Bn����A5�"����;f?D�a.�S�n�e/^S
�T�&�(��g�����Ti��N���/�v�FN�L���?>k��G�g��/��m�c���z-�,$zr?x��?����D����PK��AW<+�>zubench_indexes.sql��Ms�0�����^hk����&L�-���a�����>b�C{�v��1�tS2��~��z�^�}���N�P���Blx���'�HK�R�����^�{�X��l.y�q9�}��`:����?��}/�
������g�7��g�;�94�a���	�Z�Fx�O���h=��i����8�|��=�m�{���5�����Ki`2�/���u$�\Y���W�������=u�����
��#��Eix��@�-7X�Q��"��6D��_�#&���S�}B-�e��t^����ZYW�l�����)�`���:_���h�f��?��Ei����sI_�Jo����&��������q���#r=��-g�S<n^;��.���
��� Uy��lz����.]��O�f�~Zr���a7]=����+,V5~�\o�
0�gm�-1s�b+v�0��{;KK�"� �����%��	y�ND�[�fJ�"�����C���wh8�y���U�w�-nf�3�D�'�~6�B�8f�:��8Z����#{;�s�����~B�N�p:��[�H�J�x�l��t�j��S$��R�b3�P�Y�7��}r,*�9�b2���_!���~n�O�<����<�h�M@�,/�3�hm���+���� �j���2�����OJ/�H3�m�����p�l��Z{o���B��9Y�5Y�
Y�-Y�Y�=Y�Y!xE���2��2��2�3�;3�[3�{3��3��3��3��3��3��3��3��3��3��3��3��������;-m6���-��
����[p�=���()/TH�&�+p�w������'��4N�D`����,P��o���5~|��$~�%K-s1u�`�a������5p������������~Ww9���O���PK@�^W�����O
�z
Perf_results_v14.ods�|uTT����(�(
(���!H)�P�=t� ��""�-(1t	H7���H����Nq�]�]�����t�3����s���s�P����`�p�� ����	�d�d���2�@�,�=�\�y��-A.��v� ������������fen�nke����I@@��	��F�_�g�VZVGs+$�;/��������6�������k���[ms
��1a�,���l����i����i�u�����%��4����{�\���O�~�BW���-���,����w�<c�V}������I}������A����o��4��8�)�t3ws.`�U
��`v}xz�E�z$
�9E$���+�]����-���H	���0�%z�<���MBB�/8b����������'�7���G^{���cR�����@J5|���7^�i���������P���4�hx!	Z��6��-����	=�p����Ne��y��0������t&$��m�+���*���Gd*M��jSF)��E�����i.�
�4h�Y�^�)�����n����;�����s,����!L<����b�&���R��R���������eZ�`(��A$EI�R�Q���Q�M|���c�es���+)k]��o^��!Ir�a���$_-n2v���T��4���!*�|��h9%{��r$
���������D�� R���C�1%�����B�^$B!��>�-�t������������W���{�M}���?'���H�\)���`s�"������@A�F���N�����J�;Sun5SE�%H:���h�`��`d\10?��
��k��a�r���; �Zx�{���^������7d���o��q���y_�	!|z���nC�
������``��r�"B���/�@p��P"��l�M��F�J<&T(��
�"�R�����_)��*��v%%�n��H��|n�ZK7��U���r�B��]�&�0y0A������f3�����"-h�M���r2��������]�,��%?o��?7$o{�w��#���YeDW��VP�K+��Q<)���t�C7�(�,�����H]��
�/Ax���6��������(�����G]�y�sX�a���O�U%EFb�c��@��Q���R	���VRWJ��}(%�ks��g�@� ���G��&-���b��hdY�����#(��O�5�{�oR��a����K��U��X�z�O���J��>�4����'�E��� #���'��qvna�7��2R�=HdBt����s�}�V%�SL\��
����kg��@yI~�.�B����{n��6��Z���A@DK����?. �����(����r4IW�P#]�$?D�h�>�Tab��
4�����E��*2�����>
G0��o�!�:nq���
�>0�t�|�3��"������VC�@��hf�=���/��0M3���E��li
!\����x����o�;����[-�,Tm
/Z�����W��$b!�?�2Ci��Hz��U���B���F�
*�U�^���$�A������,�:���������al�2�-�.r���������F�D3�+E��2&����}ihyt��A���J��G ��w�O'�tgJ����)mN��i�����o�g&F��s&I�L+����z2&�5���ya�5$���p�H���U��n��2��@n/�����c��>-��{b�YG���o��[���@2Z���h��'�L����t5�4�
�"����~O~���G���4TbSi"������H���^�Nvb�T�*��PkroD��K�cvuj��/T�}�F
���Q�D�W��� ����`/�Jb*��#t�'���a��G�!v��#�|�� `�!t�di��`��������+�
��X!��_��K�����)cf}�r���?b�cY(���!��L�kC����o
a�����Vj���Ki#e��=�a��������F3^�
;S���!�����{S�b���M���~q��[����z�Nd���z���)��L���}���.���p��G���>����u�au�f�wu��v-��@�o������}Jg�����Y�'o{Db����A2���dk���mO�H��m�a.����b�K��/���$g;@b�E���l��Fq�5�������C����2�W��L��N�]���*������2*�y���F�[x��R1CY�n�&�W�{�V�~�+A��{=������7�?`^�0��TT4����x�=m=.i���:4q�����yq��m�P�s�f�d9�A?J���P����;V�U�K�	�g$���L	�����_:������SL}0�b�:�~��+���Y��Y{�W���;b�1r��B���<R����>'�i������he����k>���:�m�
!�Y�c2&<E:���&?i���xP6.�g5�����U=��60�arz���)�*�����?^+��Z�]Mj9�������-u���'��b����9��
V�Q�y�R`A���������
�j��5<�7������sJ�x�����aw�w��]��G��:��+w�>�Ct_��V*�w�Z~�}��kM��F��b��k�$�H�#X���������S�=>l�>bTZ	l|����Q��h�|^D���O���������.��c
�O�3.8R�Df�L��b���@S�~C�Z�������w�\?kK[{q8?����[�,5�=�g�A�S�����]@��/�~���&A���ds�����p����"��6��2�����gGbc`/Sg&E�iB9���%f�_EIt��p���,�����IWr�Y����
H�6%�p�-��<���c����Vz�{���<���1�J���8tL���YTh��������������V
U|�9�I��16��������Tp������J`���)��������t�^,��`���Vik������6\��V�JK*���m�������aE��D�D���w2)E�)�9�J��d��&����i���d���������[[�;��5�^�"�Y$�T����>b���������p�x`e �9�]�d��Nq������+�d��g���h�����
�V���G��&>��yG�	�;��:�z�R�h�a��K[�p������_i�{4i�8?Lgcl��g�_ ���/^%w�!t��o(<o����D����Z��������f��:���>��:���2�'��_���A�|oM��s4�B*�� �5w�5]���s�j/�����;���sK[V���:1��z��'��h�s�m��B����
�x�)�Q_�XY�	#:���t���ej�l.s ���C^�JE��icT*, ts\-
�F!�q�MP��)~BY�+#1G I��_��I��(e.���7X`�6���O�`���h8�����J��������*u8�8h��-�t������C��g�H��C���� ��.R��KB��B�O�
��'��S�{�R^��^t������6��0���Y�j	���lZr�~�����'.���J���.�����x���1L�Q�UMf,�<t���|C�^��-������o��^":JGdG;��P�}����U�E �D���P��up�C7v�oO�Q��<
b��g���A��U�nW�����
R�c�����NA�t��\��,������H����E��B��"63�h�������>ZZ��;��o4�;�E*:��(��Q�hn_;d�����(�C�<F�#{�E�R9���$t�C�S��v+%����*��D`f��t��r���=d��$D�n�f�s�1�[^m��"�[����TYsm��O0��������7}<�!���������8E��(�U����r!��|P��/�P��������_/B4Fbq��

�6�Q���t��b\]�$��#�#��h@w�����?�� �#u,{���~x���t�[k�*0:�^�pZ�5w]�%�wAcE����H��t�����`D
����'��T�cJ�m?<�P�g��!��?�N��)����|�ye�D���(?
!#�����z!J��ZPBj�y�5�31J��Y���\t	������L/�H�4������l�m�U�}�X�2�mr�������[��Jh�1�EV�m�#c�??��R����`���
��;BY����m#�$��B#�nl�
�����R,a������^<��D�QO�j��|��,��xfR�}�;�"m2:�60,�\����^XP<?�Z[�'b��'��.��
�@o�6\LB�
���@Y��������F�Yvj� S,XP".��q�b�`d�v��r�1u���]���d�v�+���W��b/\�n|���+����D2��B�1~3�����e�$����n�$~Ce#�%�l�{�0�����~R��W>?|5����+��6��)p�)0��YZ����($���1D����a�<ZW�r^P5&$GV�*��*��Hpm�VR���Wl�P�
.�����)�%?m��3�x�����&����>$,�N��D]i�?��LGm���(=��dr��2���Z��&���IK��������A�kO�}z�c��$u�>�j�<�#wv�}%G�z����wb�a�^���@	7�n���-�M����@wTuX�Y���d�}}�I���#������ic�Twi2b�O�3��Dei���Y�/�]�P���]��"-4�2d��Go���D1C]�p�hD�p	}������^�\���=�me��k�R�a{l�q���R��
,���[�&�|��G�
����Q����_��"h|o�,��{���,���:���%a��eOR�\rp��?a������!�-�YB�A��F�O_gpH����DX�r��N�-������T2�jl�jj(���]r���[�g�����k���vk�(��u*�:���g����3z�����n�G"�`\�D7U�� �>��K]����!B�@�{��5!�.�@���u�,���0�J�v��c��`����#x7	V�>.�l���R5��e����|��&�����Q�(7���88����R�.�����;i���������hi����6;���OP�_�K�{BO��O�k���>c*�O��}�������G}�c�S�!8���M2��V
E[����Jy��>�no�-���F����3it���������C��v���6E��������l�F�q�j���x��t���6�	����noWluG
�8����&
B~4l.q��$��uB��r��~=g%�%!���P�k�����C(�I,��ID}���	u������~A��>B~Hc	�|����.7�K>��Ncn��X��������	�_J&��]
{���E_�)��p��$��������56�{[�x�������IY��Pj����K��]m��=�?��
�"��'�!I�\����#!7~k71���x�A��	
��]���@�"�����j}�nu
%�x
���2r7�)���Pc��-z�
=�'mQ���=�^��*�}���+���{i&+E�����5��i��g��:d{����IO��}o�c?�5q#�nJ�v���f>h�������M�+��9�#�oa	��J����!v����@Ou�E�����3�7����F	��\K�G�h��DA��Z�l����_��l�Bi2�~���I*������<j6TE����z�����J<e��_rjm�AYUR5�E�>����*�a��m��6�^�����GI��S�%M��J��Ms�������WT\[�g���/��WQ�_P%55X�^�=�;�Zrf����CH��������l2�����4
!�dZGwl�����F�[��y�	��9}���������m�D��������:y�0�o�^���O���-��6q�Y�����'y�jJ� �n��x�4���(#�o�6"J��'s��+A�������J�lrx���i��$>��E�%.x�AM
�����������Q���,B������Yi���L���z���/1��	To���ci��	�[��k2���7�9�Y����:�!��wJ	O���^D�)G
#�=�j�tt�|	��
�����l�g=�5`p�K���^�Z@v"i�3���6A�e�KU�P�i�uG~*R�-a�K�gD��&�D��%�##J��
����z�jiK(���U�U
� Tr �z7VHn�gu��W��x^�SK������,�3���Dd�~,��NI���?&��1���\~����;?�kg�0�3���J�U���#���1}ap=��w`s8�z�kb$�I���rd��`���k�����}�
������w�c���S��x�rI���Q�kG��b\���12>����%�wD�,�s�.��[l�GX�u8E�n�������=�qUZAeF�'��]�SC�[Q{�+�0vj��yg�T�D=�rB}�c�J)���nT��V��#��
{����*�1^
�i�=�e�Q��Y��#����,9������am����xg5�����<�"-tH\�
���-�'���xUcs7�k�6jqh�F�����J������fO	Z��H�������U��W�Qo�6�
B���Gs�H�cJ��E�`Dz{�Z���o"�)�T3���x��
����r`����c&�;@c,}����12

�	V	�b8+�Z ����|����#p����Z��|!Q2m�D�d�O�����6��z
�=7l����T���u��3�N�>����~Z@Z�U��j��%?Q���z�q.?�@7�d
�U�@��q�W�x��-O�wN��>������q��.�U9�V�����r���>�bxo�!�~����=a���ea(9X��
�����������&�EI��A���mGQ�`��@z-
rT}����!� �l��E�
��<�9�k��L�Og�l�I��z�"H�S�D!�o|�p��]��d`(Fw"�Q�.�a��IOVK.�PwK�zB!���
W�0��"���Dr���E��D�4�eCo
"\8��2�����O�T���I�������u�b/���m�����?�
���P	��S_���&���<�;ND[S3HB��?U#'	����c���O)�e[�;�������4��c	��e����/m&[���=%����s��J-W���)���\�����E"�J���:7:��}��(�'����(;����Lv��??�V���;����Ps�'\^It!���
W*��uu��F]���:C��R���Y��W%����%z��8�3qD���'����A;������������N?�F	4����|�8=|�9�h\�6����;���~��SO�G����������(�=X�XP&q��������i%����x���/�����|X���nk��fz%[*��+n+)/.t��+Do9��d�����X6)�I?�o��$��d�C���q��"YH���;xem!�H�e�\`��!|������l�zx-��n�p9�R�e
��a������w$��:��R��}	���G�b��q`���~P���b�	H_�H!s��s��%D�����J�59r��C���sX"����9BA3�nc �?�j�~�����nr	.�v�M;6\��~������5�g��!sa�^�q����K����P�y��
�*��������E&2����������M�-�,
5������}}�8���������4�mI����i�g�i�����R���C����L���(�����H��^�Jj��Hk+[�x��������zS�onk�K
��0X����<+8Y
��qhb�
�)|7�������ot�,.{���g~��P��DM�<LU�p]�"�[r�w�:[��=�Q�����VPKx����tC��oj&�Sa�oGV=�7��V�Xr�$��+pk�8�����@k�S����W;���MLbI{��H=���6�v���nf������ZmK��CL���9��`.��^���1��:�e�+M���5y1@�����h�O'O�T�@l�0��$�5	xBhV�������m�r� �*��0��k�/v���kIj|�_o���M�G����#���7��)f_�i/�^�s)�fi��E����|�B������L�}y�.�[��HTa���D]������/��$��_(�����-J0��'-?��M��_a��@!�2�p/��5�:��L��������+���cO].�9� BT:5J���?��v�3HQ�����R�''�
���u
�����������0���T-WG�};��
�8��|'��a>[���s����-�B����v���F���yLm����6��l9���,)���3��u��#T��{����mK$u�y%��3�~N$��0%���9�OB�������S�|����	�h���H
���;��WC��2JJJX���2J�������z�k�m�p�n���\�xFf=��Jj���kB���<=d
��T����U+q�J�����*uK����5��h������+�n��e����A]��N9I&�H��=b�q���B� ���O�u�\�����,$�5�|y�����X4	�w+����#��VwV�*��"
���������S�*�?)������K�t�U�X����U��"/7���%)�
T������R�8~���X���'�D��'�����+�������sU��c��U\���~�-��5�c��H	����L�t
Y�U�n�hg�kMt4"\99*�*��qEN���8z��$-J1LR���@�`��������	=�E:nu�}nRG���J�8��k�v)� ��]���Vr�[VLi�������?P���_��<_���*�L�d)P�B}J	(��$B�b0O��up�7P�����E�0K���c��>�}W_��
��Q�&=�B
�%��c��/h���1����d�4�_#�2>hq���@b-���w����r����6��L�����
�l�u@2���;`���&x�72�K��,�|���<���O���h���s}D �7]��K_t�-p�^X��
r���-P>n �
(�������EX�"n��^�'|�Z����n�=�a�s���&n�$DhM�����#PU�%��� T�w���l����XF�q
������D�e�t�`^18�OJC*�u1R�h���kG���@O�)-��x%H��w�bQ���E��S��G����XS3���F�?a-\hi������Q��P6|�1��D1����w$�,L7 �P����DL+�8
����q��E�@ONN�s4:`�>�Ch(Q�����$
�D�DZD!+������������h�M�=qAp�o�]tO=� @(�(���#�Q��6�1L�n���T��'*��[<0��f��n�����u��9��Pn�^!?@�[k�S|���{h�I��0��
s�lF��hT�s`��i�aMS��Bv�m�X���5MLb�� �@���zZW�F�s\����L��PFV�h`���'� ��7�#����]LB�V��e�?��K�Icr��V���9s�H�]$��\��B�������.J,rHJ�)�E�����&Ft�`7[����s�E���;�� �V'����3��,��[/&,I���B� ��&����J
y8�.�2�Z��5�cT����bMH�}zI���;�
`N��<���F+��(L\JR�+�MGk�SP�
���.[1���c�8	b��{�����s������u���>�Q�:(��o��{bt~Y->Q�x��k���V%��Wym�C"���<����uRh����A6\Z]�$\w���F�������UY	2/#��,:g��a#�W/��1P���w�
m3�3�ncp�C�uC4�O�~
��C��������1O����M5h��D����5b;}}�C���1
L����<9D��=��Y9�}�5�qa�M�v,��H�YM'�;{���	����r�+���t�'�V���d�B{�`�v���������m���cD�7���`@��;�m$���D�S��r@�v�����][���l���������3������!^���s5�;1
5�kD5.[��z��f�v�X�n-�J���z�n&)�<�\kyx��X?k�7�~k�^��^�s�Yx<��<;-RF�I����BG	�_��[v��M����E�M���dM�D<<0�6s�2L��FL����
�d�y>|�R1���s='����#�m9s*�`YbY���;U���e�e.������b��++��=��N;<����4���*>6/S�����g1�B��pY�S���v�{�Z���r^��D��;�o�)xf�70���%��j��+#�a	��������#�'�V�mc�EsV��y��?L��k���������R�,�Vo������s�c���	��.��z�ih
�3-�*�+DeB��6��d��a
���}���E��#\����c�
,�lf�J1�[KM&�3��~�����������-���[�#��t���>���=e�g�v�{�D���]'��)n���������v�0���x��~�_�<��d������B�\yA1%Hovr]���l9���__�a?~���0y��&$�����s+�	��mY����!�������������3]�6�M
��i��e�o��l�]*g�K:D����z���O�V����t5ZM�j��?sJ���=V�$q��
z�s��v�8��e��}���^�/�{��3k��T#�
O�h��������Ej����U	AF�
�	�����7����O�9�+��p������C�����@�j��,�i�qU_��4h�
r�0����8d���J�N�/�{��i�q����,��]�?,}��!�4��*\���3><��\���
N�2�
��%��P��+��2S�Q�t�wL������Z�u�hjw�o�g*�!O�|��W3�B�9-�|<l�o�&���<J��x���6T��5y��<���v6���;��,I�Kr�o"������������,�m#P�|����v��Vv�����O�$UU�V���0�?)b���0K�9�7���aG����E���n��8�q2������e�7��'�y+��1k�@$�y(�9,��[��a��?3#���7^\SRj���K����K��}1�����J[h�bn�$��`>
M5O�(����%��<*�b���9���d4}��L��%����M��}z�����w�%��V�wg�7H�/
9��{��4��-�����c�������7��� �u�����l�6e���-��J�_��O���\��sTF���,�=n	�&h�.�����
����f�Py���e*\���n�g��H�.�������������A�XN�o����/� e4b�t��b��I�w����g
�Gm
!�|��rj�!3��Tr�~O�o?��y>Y�*n���������{�����]�d���z�10$)&����7-;�R�=OS��p��%"���!�x������@L�����K
88#�K�=(�P���K��5t�?RDNK�����j��cd�}����j�$aN/�

���L�2���\��B������J���_	N��#!��?j�W�+]{t���Z�vG(Z�_�;jTo��,Z������Xk��#���EX�i��v
t��y��J�:�6���C�%z���-�P��w	a��(�_Z�D@��(�\=  D#�}�
QdD!t����"U�~��.�rB9G�}�i������xJ��.����1���[���v��m�^/��P'M_�u(4�-���L�t���
���;O�):q��=]����������tpF?�HV��%w��4������Aa��u����!7T[Q��^b��w����yt�����3y�����=x����f�"�YX����tmc���g?%B�z8�P��/[.3��]>�XRA+�q����?�F�RU�,���	�G�fx������n!O�C�bP&�n?��;1.��X�u�
�7S���T)9�w���
� ������tPZ�0x �S|L_U���j�g=���D�0T.)����C6�R�;WO����d�������^9x���hX��X����7L��3��C-pC�=C�y�2�
w���IL?��z���yb	�&a&e"�Iy�hM�d�c�s
�w�(�����_����zRa;��0��A�
�m�0}���� �����r�P�sdbZ�&��IV������
UO�1���g8��yXiu��8��I�8��U��a�0�
OE�����_0��]���<��������sDU$��������|����Z��-�����8�2�&����=
�N�A����^tb�/����(�xM�#d�J`J��n%Q��1��N�1��*��U���t�F�P����
�~tnX�N
F�o��Q��t���LT}h;��t��|����t��U��q��g����NO'�jGY��1:!���2���X".�&)��G�h�������#�	S�X�����k&)�����*��y�
�!M�k�=:�����
�)�{��e����d�I�q�I��/��}X!�+3
��u�\,b*��He������u��Xc������'�yO�
~H����lV�7�;�cQ����T!<�A��L�sy`�-�3���E_���wv(�j�#�V���M��I/@�6js��H'��`�������w���%ZH��������<Lcg��5�Fgg�	���-�q�����~���P�4��l����g��t�#�*��o���=W��;�����	����d@�C�Fr��
�7po����9��.f��^1Y/.�:�w�%��������{�(��4�@�m��L�g.S
^��x%[*��+f������g%S���������X6-E^�!���
t��a��L���"��b�:����s�:U"���$�exUF�U�?s�\z���nwr���^l��>�9�t�g���Q�z��o���m0lY��Z	�T_��zgC;l�([��@�AV�4������a����X��dbMa���S3=U:qB��,�3������,v��3�(��>#�fk*T�p]N��1��}��@������}����^�k1VM�T���Qt�TC+�����#s�ks���K���mh��X��d��y�lng�U�t����������W���*�;�����C\���SGCB3*�X�� V;�q%�6�����y6��M@������5#�F�����,V��/Gn���M�0�����k��<y'4K~u"��}� F_��L��S���z\�
��
�q��_�S�'�4>�;OT��
�������&O\gvou�w�X��3D%��s,G9
l����y�@i
�D$�X�c>Gt!z���m��v���k���w�����T~��7��i�d�_��+��c��!%{�������5�}�;	C�����y���QK����o�������]Z��o�B"�n�qu��D4Y���_��b3�'ea�a�����N5#�������@P��Z����+X�m���4>����a�n��b�&y���'������!�4��,��e��0]qx��t��g/����������&/����"������{��M���9h�4��������!
�����w��j��`�<�m��V7
�����O���\�n������x-�(�e_#�;0�&��[0�����|����o���D�G}#�?�	X*�8�U��UI�����S����np���_��X���[S��a�����e��}H��6<�1� ^��*��THA��8}���P|M_�e�J
���������m�;��e��H|c��pf!R�����]|��^Rp�%���Q�j�&�m+��X�Dw<���7��'��]�\%f��9�q�TE�hI?�k(Tr��[w\�n����ot�Q���
}w���\�(��o�:��wp�U����gi*d�\�Q
��}eb%
���v�
��M�(���Z�7���d��@����u�]<]�/]�7�����>�}��b�3��r>%�`5��r5c�q�R��D�T�e}��1���;�B�fkcE��s���#5
�fVl�����
���Or�~v)��<�1
QM@~���>9��(\�oa���C=c@?O�D]�,�d%Z�|Ml-������ �q/��D9�pAo^��u~X��������]�yDH����S�����Y�o��}�k����������d���������]G�B�y"��Nj������6~��R���;v�x���&�-r����#_������TCA����ov���i�x�m��v�XrU}������]�;���[xb��W���f���P��?���?�k������{��� �Z���"��
j��nV~bp�K�LJB}��i���'g�K*�{�!?�
�=�GC0��7GA��%A��G3T��u�5*h���H�
�
 �C����VK�m�������{#Q/�y���!���s
����+��[�2#��A*��!��S

����o~@}���������3�Xd�E��+]i��e�"PyM���Js%C�HW��k5(�P�o�9NzQZl���&�#��tF��B�!��h|�����y����N���^�M����w�of��pk���u����T�3K]=���0�(�C�7r��J�g��	@���<4�9$���
�� �B����U�_
B�9ZmR%����]����F�&����m��v�R��_�_i1�Ak��<t�<x�/���1�9��B���)�����
I[�!�~U��V����.�g��p���3	�b���E���4�������t�-����r�?\0Z�����x
�����'�9"���]TE��F��6o�z������<�-3��6ym�?����g��UD�����-p7���~U^/��
#��cj#m�#��:8������"c����Vb������?�0���	�^ ���H��������o�.�wK�������!	���E�_��g,��a
�eF^��<M9�=�:���p�F�m����G�y��O@|����[�Yj����l�P�h1'/���������T11��(�?����s�'��������Ec'����5�(f�����������Y�w>b�c3������[�^����0I�� �HC�1��eL,���oLb�7x��Ql���#>�=��M�2Q�Z"Y7���
x�C[�F*�jI�L39��Z�
���f1V3N$���t]�wW��,Q���kf�,��2>�|�����������9��B��lY��O����w!�H2���wq����k���J]H�`4w����&��H����m4T/"F�����r;41;t�`�?�,o��iu�0L�z��1�����i%������&�[!�#X��q���i
���
���y�����^��]��M/�aB���7���.4�A<$����� ����1��r�Tq�@G���Ui������^�C�aq��oPC���(a�\���������VNZy�����.k�<������y�P�3����4m{k�sn���~���|
\��<��/�S��i#���H��DRH������Qz���bI!��F�k~�rp����_�/����m�M���el!���CE�^
y(dTI��`�U*��V��������?��)��2)"���(������h�=��'rQB���
��
������%��	�R��(�U�bj�<���SG�����5�{����0PF�;����rr��x������x�w�	����iWxL���gF6h�Gm�\�=������W`��.p��A�������TI�Lkr�O���$�w�L������1���
*�u�@&��`?�]����!HO��?��0U�G\��L�K'q����ha��M�����7e�D��X��U���o��A��CGx�J6���>��l������{n��Y�x�-��l��0�8��M�����RaX��I��=�<�pw%��,��s����?LZ������t�_�A�^��^c=���od=pW�-A���Kk^��Y�p!���N���d����Qu����������N�dB�q
���4�����f%�c^����mL�|�N$�n�{�DB;
0W�:�>U������Kr�w=�ZB/���UL
}7b��FvGM�"�x�?�3��Z���3k��p�a���	���MK&����77�d���jcL�h65����m�<)L�uZ��;]pa�.����s�)��������BF.�yec7�������	����M�Q�p�;������	�V�D��jF��Fj����)�F$�(������E8^m����
���WR&y���kIW�}r������v�>���W�
�|���'�����~-XD-��o0XI[�?r��g������q�<]�]��\`��(��#��� O�9� �1�m
�8��5��Cr$B� &����}Lx�[�:r���%��������7����������08��L��y5kf �~��QP��;��lI�^���y�����aQ����g���a�l���~�Fe��,/�a��#;|V��E��|������s2��
�_Hb	`��M���rn��:Yy��|�c�J���]{yrA��������g�x�n�B�
��W���-@�=M]_���+�;i��N�'�o�]�"��QT����,���EU��$S�F�|�`)
��'���T�G,-m�
_�W����c
���u�E0D��=�^�����<�Tgw�,|�=�
�����^���������t��%1<�g��fP����_z.�oo�}-�Bg6�sp�!��m��������d���B��2�Iu��X�%b��~7��!�|��:}�u����(p8s":���3�Q�L*���n�f�$0�)'r��&<B�K��W(�	r������aG��x�1����vX�W�)�sw_G+wd���J�q�{������U�W����)��C A�y�G���Z^��a�{c�+'���Q}�����~�(�*a��qW,�:���Q=�;�<���n��v����SQ
��=�������r���V�Y��{����F�R.��K���:|�[����&���@v�G���[ExMiO2��4
',����[�aR�Y=��=�{���t���������b���u��bA�X\C������oX�t�,��-|����q�od+?n��:�����D��x�e4��L����M��f���d�'4�?�*��v�7�`�\���'�����q91��*����DL�}Z�"�'�T��t<�U(��s�Ed�-�F�G4[���DR�����]�P�Sq������$�'���� �����b�%>I���V8�e
V��7T8B�,���"OhS���u'8�'}����������6��M�1����V�u-M��d13�e1�333���,����������B�-�yt�/z��L���_��<�XQQ;��2��b�/*J���MF��[��'%7O">�����v�S�`+��o�m/�_�0=�	~jc������alg�����������dC}��X�z�xe���
 �
8���HpU��n�k���}Y�L�M�y�?���s�' �q��#&��^T�t�g��UN��V�k����DN����Y�4����*��f���th���,���8/����o���8���(��MP��q;����t�z���<9���5?��v}��v�B�� �_�X�Flq�{�����	8Y#[�p��d��<���<.}���lvT�������f?W���{����r�jYm������[V����cS��v8�]���;��9�3���}���&����A�<��w���{��.�V����_��a�FU�����d�&��n8�	D����Z�Z,�q�,���#W�0���]��`���nL���V!f/����)��*2�	�1��k�2[���i��#�}G���Z�"�k��tC�Y4��|�x���Cu��A$c�\�~���}���5�C��&�����b�fY�����	
�C���Eh�zc��M��)?����szm���������
]�Rw������u�mn�l�i+�C.j��.@����U����]��e����������j6��6���pL?��d{Q_�n4�@��%�8	���e-��?�Ps�]���Kj�����3�Be��N_[�:
v /K-��p�:�[��B1/��x��9Z�	~�y��ZWH�Df������M�%�E�'r�v�"�����4�YW�r���>��V��1�r!���lA��,km�1�U$~�EM��q#hN��K��+��E����x[�F�](�������`������M
�h���+�/;�`�P�
�KtK�R�+EX���M��z���(��}��R�;���Fw���2m���Oz���k�r����E�f����
��Z�s;��
��a��t�vj%�[�RC�P����>3��v������n���#��TZbtAK������r%;{G��L�d�t��������{7��~7��=0!���k��5��������A�������GP��y���Q2��|f�1
�|�K���1���PJc�4t��Ma�4�������1Z�`'[��Z�������
Dr[Io�$NW.�:��["u�����3�
��/����������f1�By�UY�=�����//WT. \��\�LZa
�]�m~�'n��;�������|u���%`e�/*���*1���sw7�2����_U���e�X�E�8�l�Z���g���	���d '��`��d��<�\�WN�c����=�9k������
[Y��P�y�!�q2#���
��6��Rz��i��^*!B�H�E����zb�b���g.{/h����=�}&{/fej����m1}73�~V��Ctw����������E�3�q��!��P'2�An�������bf=���{�X��<v���G���n1b�\uMfUY={�7�/�����k�)�9D���-%������(�DVr�����[j����J
��T�E��Cp�X���)��� �D`��f�K��%�eLB?I��
��>��9��Av���@�"6������9��:�c����<�M���;/����dG��/1)���o���H�)i[��t9&j<;�Fz��r
���k!bZo�Y�i	�4��T�W{��3XA'�f�����ENl���]����z��7�������J����&��20��/���5�s�l~�k+�Yd���X���g��h�Q�_<�U��k���t�<�������22��'��s����L}K�!<��������n��^'C�AMk�)���������Iwi;&��$�7���\���
:c�g��r*����rGh��F�2p��L�>���Ky��~���O��J��3G�j���_eW�������9�'���~���V���7���7
�.��Yb��y���8"�)
���I���]M�>��u{��QM��9�����#�FV�i���a������4��/��@��*�_'V���Wr��!���'�����=��
<�|�>�<G��sM6�/z�?tDS
���|���*�z�I���t�[��d�]�v����a?x�H�y�!��d���#��d{��9CC����r�-;HO��~�	�V�a����h�g��������$����;�q�+@{����CG�=H6
����Z��?�oD����ch��[�fu���]�_<2�74f
R���N$��Q`���Uon�SNQ�d�r� O{xGma��3t6�Df�����+G��%q��O�[Z��05�=[���<���C��c�&���!>��3�>_e��5���G�'I%(
D�H���!�����vD�|0�������dN�G_�8s�		��	K��
�D�cLz����=9Z�8���n1���q,T����&��cQC��;�p�g<�-��yc�a��H�|| �-�$�h���p�'����x�H��P4m#�(3�R������E����d�q�*�f����E
���79#��{_:���i&�y��0	��O-h��G4*����D�a�r�����KH��	1����������/��j�I�^�g}���rM,N���KR��C�����?��>	��KnU�2����`De���Ny���k�f�sH��u�0�J�K���F6*��.
,Qe	��I����0�M��aq�����Jg�l��'�i�#CE��E����P��N(%����
���^$b��@DQ�v���p���3?\*��c� �#ot0�f
��b�2�URD����%\�!C$����|0�.�����u������A�9r�XJ��b�Q�-jQ���2��r�)�_K�A�	�iR94�
`����:B��~�;���O	���(��2�����>3A2�N��;L�?�aG�������ZBB5�s,+zW�4��c���,>n��U�S.�L�{�?��I��_���_������5\�(�8C?S�E�%�D8nR��w���lLp�����4E<�;eL��T[��H@v����c!�)T}�w�@[�t�Y

����`;����9-����_�������L���
���yc#e��H2��X�<�j�,�:��
_8o=L�������2gS����W`@��p��m4(AJ�Y�J�J�
��,oO.�����������8��P>�g���d�������_U���{O=�^�����9q�M)�sf��D�8TY��]cQ5`�����n��!r�b�����C�a�o�TF�r��y���$������gXEI��BF_���Q���r�(���|p"U�^D��dGda��J�GA��n�����M�m���
d��xD���������w$>���M��F<H�F��F3�?����%$�O�,���g? ��eb.P�E*��A�aXN�v9�)�C\���#�f�7$��+���=��#�5����[u%����_���|�{�n��w�q9���;������w3�]����`cj�bd�������O����M���kK���������c����lgg����������%�vD��������������������v����]W�Z������3�������M��������Am�������j��6�������m�	�����;�?��C���7J �Y�m�2G*���QD�G�(�T���F���X�m-��Rz}�H�.�o'����[���}��F�^E���m#Cj������������~CO7]�Im�]������da��p��������6�z����z�����)�i�6;p��sF������[�O�d�5[Yi}��:��(��[��m�T��w�~�9����+���:5w��������G2��Q����U��*�LN���Z�z�x���qE[9��9��xF;�y;�L{w��X��d�1i�e1N�����g��3>�0�pn<E���W�v���D?�_�4Tz:(FF�:��
�����t�]E���"��.P	�o
��������rGkC*������W���@�S���D�����
�&�;��t V�~�/#i!	-��'����(>\l��*�ImN��
Z9���7�h��_�^�R����L|��X'���#��������x��X�PD�]gAfQ���2���g��<2�#E;.t|�Y�{.1�����G�LO_�v���2=Z���aF:f2xr�a�JE��@��47}Xs[�����z��������_�w�gf=����s�p:.-���9h��S��y��U�}iH;���8������T�o�0c�g03������63���f:�����y	
:+�=T�[0����X"����a��c^���U����Ozj��'	�u
�q���]�h�h-��;T�Nw`Y��F'���6�Y��*���@��W�}@�����|�����5�n�f�}��>)���of2C�{���V>=
i�;.x��T��7<�
:�����6�E8%4S���K�l����;��oj(��]�,Q�;%�
'SI��td�
z8T�����K�D��Zdw|��h&U�(3�k���n��-)[:T��
F7��d��+1�S���/]=��u��f��
Z"�X���!���]��lJe�<�q����O8+�$\on��4�
�!���I#R������(s�q>=;��"�@u��X����1x����v R�c����a�NI�t�8������1�

c
�T�~�)f�^QM���g���bNQ~`����q�/���/���=9U"���Q��#�4��K�	>Q?&��3�~�81�FWh
��=�|�O�CNm��
n��-p�O-�5�"���Z}�59����
�u���@���%^
���
o��	����OO�w�{����Sc�e
{���AAU�H�����MQC1$=�o��eVGS'����Q���F�8�&�?� ��� 9g3��s��nwV�w��j8^���]�=�3,L������x��N�
�
��3e�C���s�'v�d�g��E-�
�=�V���L��b�7���U#t�L�oX���}��5f�	��17n��b�T�
z<�L/����e<�FB�E�� �t� =�$\���/��]�uj��R-�5d��n�M����$C�:m&�\�I��I�e���p�8��g~)Z���2�-'E�G$O!^�3F~t��"�5 ���Nv����u^rm����%!��R��z����T#~�bM�i���!�,�zq���`�������o�7XE�SI0��Y�"j���&�m.���� G��8u���~�\�r���.���w���c��9�x%lU#��a�s�;��?@h^v�n�'�z0�:E�>�4�L?�l|�Y����a<�Ly17i��?tb�����y���
�)�eT>
�*^z�.��������0�Y;]���|�����U/Cj���xK�z�����y����4h�n1~��)/��)O���/;m���=C������4���-;S�
OZ*�x��.��`U�zAw^&�
*��h�����<�5���U=
�a�l�L���q%w�7��fV"�N��A�2t~���34��_�Y�YCi|�|��
��6�]h
�������m�=���������gbSD��H<���/�u��G�uzI�H�e�-���&�
���8O�����*a�6�d_�����������g�:0wC<�p�>����eJ�8K0w"��|��V
g^g�S��<������i�7����_�&��p�u�����������}*����e}����"T<�r�*{��A����(�����-&���vq4$V���r�S<n���A����_Q��*��N�q��Dym$-�e~����{�EU���+�0{9��J~v��������k����9<�/�����q��5��*�}
,�X�M[�������Lv*�9�-����p�)��������[N0�=�������9��,i$��|�S����I�����>.����]�7{�8��\�E��b���m�
�yK�M��9m'd��r��U���pJ�C�
��@���;�t�����
���#�HG\i�_4f��

}����P��~p+n&m8P���"Y:�9
hwn.�:{$�X�����p�����-�~��P9�;���c�������<��*?��BI�}���3�vH��9����rx��"���-*�jV��`�����3��\[�Z���H��y%����4E���^�p]!y���>�w8$k$�P�;
?:��������,>c�W����uD��,������O��I��v����2�����H��M�&;�T�*xQ�AH�0AuN�5���DJ-;P��Qk��k�m���\�jL
u����5�
|9��C�
=���h�o�%��59`C�I%����A|����z�X���5_�b����U
�B�YcL���s���Pj\�
������&�tJ��4>�P,����P��q&����X�����Hi����'������C!G'���c�i�uq~3o�I���)r�k�'ViD3�0�S�M~{��9~�MF�_�/0�����*\�/�R2#�9I.e:j�TIv�;9�9B��t��s�UW��F���^i]�}H���?���p�!Y���9:]��Fi��7�^'��yN���X@�X���$�O]���������Es3b����0P��[��|�hWyYc
�hR0��gH���r��<���_U�u�E�
�]1� �W`�@�5:P�bNTE��I��������ws�U
��EFX�j�3x9S��b����[�������K	1(�9J�jL����`��%_E�`�z�$���J�	-�:pF�������"f�uL��rD�IGc�-���
E>��Iz���K4�Q�}.a��M����X�j��^�b]�KP���p�z{�l��;+"n���xd�����j��T�0
����1)��R�D������~��MQ�����T�+���^�H�cR�Vn����<���1���O�����'�TJjj�H�X?���)s�;?C9�(����!\��=�����Vc�-�W���F�\������6~.)F�)��E@�Z"�PSD�R�|�w���N�5gt����r��o��7.�T��[~����P����@LF�)�"�x.��X�?kX��5����k�o����s.�/X���+�?��DD��m���h�4�H��}[����F(7!������. �T����<����^���.n|8����7Y�iWV/G��#����c�l)����K�P���Sk��Sj"��DGo��#Yf�c�W|�+�����uYV~�E��������k����J�����������{���w��^�X��0���~�s6��N[������H��e�!h�����;��Y�Z���6��0E�J�����Hg[Q`���@�T�����P���p�&
\�J�b}qu�y�I���j���;��y3���4t���~�{��(�b����%�cs�P�93�ZH�������l��j��b<m�=�����X�� �_��
��&�]������O.�z���M4.�k��+	�%^u*����5�n���K��W���KL�dnJ�
��_��WI
	�V���I�"	qnP"jUY���+�$S��D��&j�c=����v� ��_������u�A5t������5���@r�*^�H��=J;����xD�������y����T���F��,�n&������-w���L�v�Uz��-�XTD]�l����b"�!B����7��r�m������AT��oC��NQ-���T�f�����R���YMM*�z�A-���y���XfDc�s�u����j��9����9��b���[�?A��<[���g��m�:�h���������)��&���9�lVP�"�X������yu^���"�����nJ�-��L*_TLdfJ���)d��Uo�\T����$1d43VN���r��;_7�]��m<�����#����3���-���i��g"�h���p�|9�
K�����I��_�0/�����)�p��+���<�e����2�Q�&�����:W�=�N6����������~����u�=����� �K��G�(��K�v�"�R��&b��iLs^"5������\�G�wE����'Vo�)��t��h����*{��R���}�]�C��-}-�ab��{��_�}E�F#7y7���:!�)���=0���#��i�'���z������#T��$�,��w��p���'�(���UAT��M�y>��8�,96��y�b�������.�����^�o�����mo������a��)���eR��[w��R�$��,;�����f�	,�7�]��_;&j��B+g���y�j��b�W�� �-8����O��������u��xM���� ��_�.0�m������O���>���7tF��9�3d�
m��f�����<����j^f��zVw���u5�d5t���?�U���i������pZ�� �����x��w�K��%�E��|���:���H�$�*?�`�aP��Ax�����)90����i��F�H�K6���}�<��#G�W�M
�L'�~��\,���������LB�[�X�C�_
�l�R5�����\�
�5<���+:]$�=G��y��!F�.�����<6L$�e$�	�}���S������2����
~�0��=������0jI�[�ms,����g��4�`��
��	R��(���6����)V��]X����\&��k����&y
����A����� h�7g�G��l�w�-��������[����{���!�`:���������O1rG��p�1�iB1�6��*^$�S������-�L�4��[a�#
���(���[tp��=��V_q�
�7a}o���c��S���2��g�����h`{o	�!����${+��f�,/���r���R����.����:�g]:�<�]�|{Q�e�Pa}�B���4�~�r�F���v;�D��+/>�����y������,2f��v��M�����7E5W�����[�.\��ZN�31����Q�TSb���Nj�a�:X~�����;SL�o���R�<����<����~�k�%�>g����3��K�j����_�m����
	�3a�w����
������+�r��M�c�K7�C������P�w�Jj��97	�n�J���Ae�m�]�������k��~�T�*��*LF_���"$�S��_�������g�K<�Ks
��KC�p0Y<im�I[�	/W��-����s�v��f���v]��`�8�>'o�9�$up5��	��g_T���e�.��/�����U[TU�'3|`�}��>�B��W��C����
����
�v�B��$�z���3�|���`�MP��	��+������+���_�����I���N�����	O�zx�����-���9�Ac��2�_f��\��
�6QJQ,&�\%|�9?��[����,
Y���
����4rG���j������3�,<=W6FI��L�K��������A�S�R�)���>������y�zKukQ��h�b��?�t7�|#�*�M����H�q�N�L�;K��*'N�Q��������-k
�.p?
"��@��}Q��xGK�
���(����\a
!9�p�$���#��*��D��D�8��u���*G���1A��~m]JW"�9���94��+NI��4<$b�^4�_ ��0����V8v9��s�^S��
w�[�J�.9B��w0��$b�����xut�EdB���y������A���`r�SemM?u���(�qG������0�@�0�!��T�
�2����!��������hG���@�����!�a]kyH3 �U�%1��v�0���)3����J�Q�����*��~��J,���bJ����#�� ��(z$�V��_�
�q�{x��`���3���~BX�B�G-A>���YhP�p�����B���J�g���(���!�����s/�b^�R�@�X�?��P}�>��op�0f����~ "</�����>G�^.����"����
��>	���W�?����V!�r�cU8`�\�J��T~�t�_�*�����?��\��(*�7V���Y�xh�;z-��`��a��#���� YU�i?��J����!S�}eD���@o��O"�#���n�
�I�91�@FgZ�_�}(o���A��([�ub�:��~	��65Y#��e^Ds��}:�;�S%��HR���$�e[��Q������c52x�oz�pl�<����APx����%E���:�4��F�bK�������*�F�F
�E�q5,��&��{��_�e~�1.P�@�?��T!�����-�.G�
�q���C3����� aE(W5�UQ�bqmg��
�F��8�@����� (eB�nR��Q
���:�����g��B�3��F5�<
����.K����;�c�g;�B�Y�Po�����&��C��V2��&#MR���
�;P��2�@��|�r
��AT�<�?�|[������0I
��<0/%G����(k�x�k�*Wh�n~��|_��39
A,�B���0��0�De�T����^���#	b�c�C���+Mp`�hT���
y�������Y��GS`�>l�2�/����s�)���_�0�!+Y�F��_yG��r2���y�����?m�8�iH|�_�e
�c�������
��/������v4Y���W�K�E������=f������}5�Z���ZS�>�����b\$�'�aC�Sj?���������%rP@Au�cyC��@���p���8�D��&))w���M�&C?����3����#$�!�v$�y��;����t�I'O���2����b�=C���`�j�Ih�lAJ��������5� Jw&SY�q*����g,��O��qH�P�p�����Kh������c-8���t#�4���j�	�
IP�p�p�Dx��+��(�w�������Gq����X�C>�T�2���t�� �o�.����&_��2@�k���S/�v �AE��"�r��W�@h��I�9Bs6��P�%��P��A�e�~EeX�����F<��:�k����BQ)7��� �d[eN��e�3G��:AW��;�����
g���4���)�I���!�8���Y�2
h]�>���\�Q�/g��TXR
q'��{��Y�n?��Lmv�%��>)t��_��`�����^�a�9�������~����1~�'bQ^/���A#9���QB���T������_�8
3��P=HA��X~&��w����]<L�}�x���],�Jr��������@����EB�J�u ��,���H�?,��E�a�����k�o,��f�:�
/����%'�M��l'@v�S=JE��z��w�"���*�*q�f4�
r$D����&���\��XM����e��FA6��Do>�����p���?vX�w.|33���)��&:3x�|�7��)�'��@K_����EM�\����iu�v�Y�k����������^��j/}�q���^�9�	���������Ez�>���^]^��u�IW7b�bdG�b����dD�k�s���,�WXo��{U�����_f��t6�nI&o_h�&����_~������:�]���NT�r��;_��E��?,��C���f������,�<��f�"��Mu�$Y������n$���C	<[i�R�D�&�.N�2G[vu���+[����8{��oiy��'�6�7���=�^au�m�8��F�f��j;M�F��������~�6vy
\�g���I��sCV���f��j���Kq���:����	�������%V}~��\��m9<O�v|���e����o�� �We�v�]V��|�����j���<��"J5�+-����M��������t�u{�f�-��,���Qbs��m���s��f��	<�I�d7��
X��;W���'�/��ch)
z�<*���2�~����b��vu�"|n�q�����&g�q�k��SU!S����`P�P1���k
�SA�������Z[�n�x��\G/�4P�uY4o����r��7��K+��
I.
������2N��V�|
N`Mk�-_���r��:�j�<H?����y:�������	<�_���������uQ��������=�Q��U���0G��N���&��?�$L':���Y�,�\^�Y.�,��.f�d�$�v��NK\����'3��,�dx*���#������#u�25�;�Lg�M
�*�7]��[	8�4��L, ����/����������9V��u�����j���A���u�$�:s_Zzo���lf|#g7�����9z����l�H��������Q������HU*f
H��O����'��O8�X�9k���\�c�"T�-L��2@/U���0�����'���e�~�^��B���wOO�V:=����M�"i3c�3k{����Yb���m�%Wo9340tp�����r6T�z�M����K\���7S�L�F�z�F_�<�����i����he�0��a�b������3�Y��Q)X���������tb�����S`�U�.-	
�Fh���G.���c�7�5����X
�:u�R�Q}�kZ�:m����uE_
�<���KO���Oz}'`�����[ \��q���~}e�*~�w%�o�<S��h[�$D�>[�c�����~6/�jyUh���w��n�r�����w�-NN+�s��bS�,N\b
;<K����ts��c&����R�L$m:����T�F"�
sP���oO=�%����8�3��b�Wt�R�IsKeST��i/+��|��%�|6�M�(�����?6����p�d�J���:��`��I����=?T���&6=Qn*akJ��XS�b���DB���W s�X)��L>*��%K������;BGj�P���%�Ko��|�%n�wSvg�:��f�v���N��f�b9���2��!sy���e4���1g�nQ��T���xH��(��y��f��n��_h&AR��K���Kg|�}���1U�z3�����H��/�G���������o]K���DX�����R{}p?�CG�>�����++��?���)V�=;?f�]�^��z��WW�!~3i~��]�'�>�E���������Yy!��S?�{6�>fZ-��n%K�Y��R!H�����u��h�qS�#���.�������&i�����Y7������,:j2�v���c���%�!]�e9u���	ie�mi����"��Ft5��g���Dq���R����Nn�N�Lu�Z������g�,��q��j�c16��C���.�8:������u�����������bq��}g$gw�=L��Z,C.���V�;�����1�GS��|���f}5����G!����o_�;$t�g���'�_�E
����w���|���x_;n`kj^�N{9�
U�����$=�NC���C���SO��-Fs�uKx�7|^�l�
�Z�������b'~��$#W�l��!:����)�����"(A,]�~�MI��9KT)N)����l���15�;�������~�ys)|�*��S���l�i�etV9����s���������)X��Y���4�X]���W�/��/V���+���0�Zi
1�������ul{�8�d��%%��@����S�7^�;DB�36W����1_�%S
c.8<�0n���A�W���x���P�x%��������Y�75������>����|(_B�a�5��$�Y�3�,�#�9P����e�f��`��������r���X�vp�$�D��sE��!D�X������mP�B'K�hEwO��`�T�3.�W+C8�(��K����$3RG�'�[0�E��q�SW�Y�"�����N���}v�!��1������v�Q*�!��-������ 
@�{�"OV�F�"���,��p��d8}1�r���4���b�9��� @
_�A1�I�)%5]����!K���������n������t	��C��
 ��C!�X�~��6`$	r��3	Ak1���W��m���DL+<���D@�*�w�D�Ap����l\�0'����i��r��L�6,��4,�9�?:�}���A�e��G;MUo��Gu��#\�*>w<v�$��XD�L����5	�����b��~���<� �������=QANw�D�8tD)Xq
*�_;NS@��!u�/�E���
�yN.�% �.N�.�|X:CPX9;X��s���@>��!eF����x��1&����D��u���L�v��-u��!���(�v�d��Y�h���c��#���G4>VC���B�C��5�v��):�t��~("(
�^>)e���:STe#u�OM�ZN�OQ�i�����1�ad������C�b���P�k�$����RoAF�>�O	��5E+�b�x�k%��~��������M�2�Xi�|w�o��,s�%�|�����(����Sq
Eg����ES�`4;�:����l��mN���}"�/;�1��y<�i�����qx+���g�[�@DXa�����|�B�|T4��t�,����~�c�I���i�p+�:c�H��.�C��<�jw{xp�kR�rH�����K���t���,�D�����|w�8�1��>��2�E���$����d+� ����6��
��H#�B�����E�*�3�*�9�mD�C.���Tc�����!t86K�l^��x2��w�����
��B�dBtN���	
u�8��M�]d�2�ha��9���c.b-p��T5E�r�$(/e����x�b!�7J�3aAf�n�
�r
8�1a�0N�	o���q|0+��\1�`C��Y��8�9H���Cl��|��<�M�R�;"����JV��C)��f��?v:�1Z2h�[�dtI
�s|��>OJ���`��'
 ��A�7� 
x�l%��BA�����P��2.PB+s(R��S�D�`0����S�2C	�������A.��R�NJ0�K���G`��]�5����>��
�<+�����9���+����l�B���z�+�+RD�����[��V�����2$���]F���i�o}���X��	��X2��6�T��3���D5�s �r����h8�L��m8��8���S8R�`��w�e��N�>�P5L����>0�������}�k�K�F8���
����)El�,r�M/��'e�lo�H��}T����,��4vk�t����	b���6�H�&#��_�j�
6������V(5�.N!{��3�Q��UB���r�|w��
<6T8� �q4~�{l@s��(����^��*6���'�a*�Is��/��\��O��.��v�b haH����4�����@>w�G�]v�
T.���+�e/��T��A���/(�$�����F�+GIJj��kAD4Q��M?����x���$��\��n�������[�P���lhm
��@����_(D��md1��M���&���$�?h�4�wm�
M�����X��oo@�J
������s�����]x^��:�=�"?�Q�A4���@,
�edN�)�{��S��n�[,�z����Q=&�����f�3b��tfO��G�����3��OvX���9����5M&�g�LB��^����eL��6�0$r�����T�f�v��N����o\�.����j����T	�5�#�d2>�R��(�%�?yWe�r��wl�$5�K�X/���v0�����]\\����?�nd�4:m]�1l*5��#he�s����n�L�84Qn���
�u����Zv���ZG�l����/W�:*I�}�p#���G�<i����^y����iB�t��0��KO�f�]c2s���KKC2�G
p���k���:e�Gb�O$�J��.�vB�W@���m�n�Tt�n����T�hr	�����n�FRPj��)d���������})x
���V�B��h42��?����FzfRTO,{��}�D��-��@����nB��40BZ��JT{�6�:V�o'�{�.�����m���{|��\�8�z�.<�N�-^]'Yg�����gw<^tw���-��5�������wM�2'����ya�����5�����M���j����A�
�?�u����M��K�`�0��]F�Y~�Z����+���jkQ��!��v���Y����E<�6�L�m�1�5�/[wW����=A^��a�^���X��E�D�u��������QC�+�U�����V'[~[���zz��>7���D:d�]mH�
|l�G�
�����:`I�������E;i�����y������_C��c�133333�cff�5����13m�]]��j����_g����fz���G����Kp��������5����2�{A���&��r��I���#.�)QcB��9�eU�a0���/l<�v���U>��/����H��M<_`�ac��+�P�gU^�AN������*+���_���-���"�1$Xg�6t�L�ENXv�_C��z���-��J��:�����u������tyz���b�:����;������Uc�~��yi	��9�������=��!���_��|���=x7���������E8e�^>�8�~LoQ����
�	������K���`G((�B�D����.���N������m;f��{�fU��w�������^����8�%�Y�&��������}�7�_X�����I�><�|����K��s�=@R������T�tYl/X4#��b\��m���E�����*B������
�u=d3v����yc������QS}�y�K��{����<���4�c��6���-������'?������Z$,<hA�Y?��_{�(�g�f�@7���^�P�d�{��oB$~����Jk�x�|���}�S��6q����������_-�}���n�5_�����Y��&Z�i�Tm�h���_�lo��W��&x�
���h0�_��dw�V��|�d|.��H�%��%I�|U���K~��^Q���1$v
���Uv���$q�e����D�{1��D�}����F�z��6� ����a}T��XY	��<��7]?��������//�����&u���V��P��k��q��g���~6`�������r���|O�N���F�uf���r�5r��E�N�hC6�t��Js��-�ea�m��FAh�o���k��~��j}h��v��4����B�>�����V�,��K�i��~mV�����]>�)�j~{=��{�U���]�%0D�:��0��I��?���~��\��akc�vHZ�?F������fh��tBkA�����������N��m%2U=��������?��-����7�B���e�D0V���",�h����_�@b��0
u�j��zq�7�������=�:��)N�bu��`��Mi���:1t����01T�x�Ruev��/QqF�ov��k�����)�iU,^��wV)�^��L�'��gK>��C��'���<�z���K�d�:�~�������
e�7������oc���i�ny�-�j��;��3���:�	����~3TY'
5G4��MD^��G�:4:��3;��-D=tv� 
3mu���S����^7+W�>���(�N�S�r���7��������l�U��3L�����Z�� ��������[�_3��C�����!g�z���MtA���7f_%dF��H����Y,���PT���=�uCQz���#l���L�ak���E�������l���f(~X<~DF����
��������c������h/s,���"I��ff���\��:Br1��c���3��G���
�g�����-"}�&������.�v(%��*L���s���Y)��$G��������,�{�t�dsZ"oyp���c0����^m`|%���2}V�'�����9�_���69~-��F���*�_c_�R���Ns<&��	�(���^~���f���]�p�%0E	s;�/i�����k8�����2A
�z�{M;s�Gm)�Q+{���o��r~��,�Z�����h��)��~�ufR��j�a��6v�X��4�td�@�G���rJ����2g���
E�
\?H��X=�$���0�<�5x�q� ���o+:�+\���AD���|�1���`��W�8Ud(�`(��SF���v$3������K�P�"C��Neb:�s��9��A����]M��;�N��k���K/HNN�S�_����w|�`x��[�^�u�|��O�gau��Z��s�d�A����S���4�������
���)���-�������p����[���������]<�<'��I{����e���q���v�Z>"���F�j�;%u��`�P"!D���6iP��L4)��}A���9�q�o)T�� Sk\�j�aZ�.9�lF�u_3�"�-�]L�b4jf��cJ�� �(,�e	���-��"���\����F�9B�A��	��R�#�y��b�[��o��M�s��i8��%�t^�&��������@�D�5T�A����`k���" ����x;l?^�X2�C�����K�Kn��aT�y����	=����A2F=C�}�[�@+���
��I\;������e�1��s�i��n����T)l����m�0�M. ���0]ivZ�B�l4���y1�P���A�<>���"?E����� NG��>X?�r��?@$� C.P��C��L�E�6�ew��kK�������V
�c�<��d�X�(�m��D`�T�u2xB��\K=,����8NN=-�v��
��(x��t�$�,�����F#fK���
�$�7L���#)y,��a��wWL�rz� �&n��E-#��#����&������%�`V�T�:�����G<��������<���������H��x���P���
.NP��k!K�G/��:���9�b�<�`)
4�a�b~}�2��0����3E��,<	j���^��jD���2(�n�$�)������8Cl*zH�8j
2���fe���"l�� ��u���z��V�@����h��pA:�V����{TS���A��g�H�6�&Fd��
��f��WE)�c9�q�'i�2��!���l���O��.��)��zve��za':q!�'�w���Z��A���_O�2�����H���B�ug�
�]�������P�;Y�0��F���q���)��cy�+OLj��/�x)����
!���
�
���
���;T� Z
Nr����	���@��/�
J/R�C3
����dBj�>:qf>9����/'�3N-�G'\z!��Y�B�Y��  8
A���0L��k�&��Ln�������J�a3m�����Iy��'��.��Q�a�W���0B�3�p��t��%�~w��x�h��M
�����P
\P
��De�Bt���Mz4`�[(x{�I��+#������Q_�L	�I�-�:sU���2�A���%b�(�.PU�� H<J7����E�*���|�)�e\�� ��#PW:mx��
;-�?_o/��[���1�KI4[�!�2��k
h��G=\s�/p�	�C���
�ziU������d�����PzI�}��"z �({_5�hw[4�0LQ����<�1_G�_��*6v�\�_HI�B�Il
�B���<�
0�k��}#(�>0��t��:�M�)����z���Q�J�E]��j!
��j�v�a,��"
vi��9$�D�o��x`9��q)�bR��s���pJ��a��:�as���/;
e#j��	������ ��&�,Z�`�S���]��U)�L��^PP����,����$���cW[�f�y.�h�5�),�aQ�A<�n<Z��T!��Y�P�c��Jz-�������w��Of����q��E������?F�Z��d�
B�����r�3����r�3�f�_m��0S��'f���S
�f�\�c�������j��O����4�=,�_C���)����������O���lM��~�4y�S��Y���E�����	R�9x:�rU��=��pV���^m��u� (9�����@������0�4u>o�1z6o��U�p�k�����W������{���U/u���:��
b���� ������"{��o��K(��Eo2�I�~=�$0��oolD���z]Q3vX�d��W�T�|��o �/\D8J�[�h��U_o�����$X{|���?Z�)`l������b2��y8~�������=_���yk��{e�H��UY��������Yn�Al�����*IOo3�
���}R���e�Z�r�g���m����5B�6;!�)��*H����dk�aC�.����zd�V]3�_~y�,~1qr`��y��^�)��a����#���uk9���,���B�F�����g��"x���/T���]��M��p�C+r�N���4}P��cL�p��X'��%>!�"����&�~����<Um�r��c�����
���t�O�5K[q��iU�,tO��+�Z��n9aSn�a�x����m�4�qS��'�,XR_��f�������7��$
S��B���;�/��>�K�M.������*OG����oM*������@�v��������0w��G�Uk���j��~��@;:�"��+�,o��Bp@j+��M�'���	��	�j>�������U�<�-��k�C@�����4�b�]u0�O����
����d��Vm8���<7��._��2�Y/%I��BT���
�)��������|2�+�C�ufn�A��-��N��'u���}�������R_C��(�_~}������
��r�&�9*�Ry\9<������?������>TH]%�}�c���s+��k�`��7��W6��}���t'e�N�SM�]�z�,�#���T��~�Z{��C� mG$�p��M����]G����:������$'��{���P��c\VCIn������/�����ew�s�u�8��F��K���s%4~��Si��i������SCf7����d)=)��}��������O�a�����e�*�_cV;F�����&<��d�o�)�6R���~W2\�g����_7mZ�tW�����O�b.������X$,=h�K+�h�����uj����<aU�g��Qb��.�C�"����{-�;[
�X��+���I����J������,�a�Q�j3+�)�Q�K��
X����gy_�Z���i����qq�I�x�K���ZY<���Hr��.�����@J5m����AL+��Wi���l@�!��\��a���N����!�[����y����l�.��t:�`.�������$
�2Z���F��]��EP~cv]�E�{[6@�:&��{7X9��:B����t]9�����+5(�bW|�#0}t�����YJ5����&N>�S���2��3K#�:a+`�����n��OO��>>o�9yk�/}2@��h����3��o+�tD$���9���PF��(+4�^�L�E�R}!�{pL:
������s��������m����hL����q�7�Yt������#6�pU���I��X�G�MR)��1��M$/u�*���/�D���`�4��U�h����w�T����45m]��u&���LH��jfR��6w�zl�������9�o�Z�����������+2	5���n��k����N}�����ye�'1�(�~;o��;��3N�����N}q�7��P[�pC�db
]���]�2�|��+��-�l���K��d�U�����4��y	����P���5.w�G�u����}�G���*��!d��8�h�{�k���S��mQ��b��O�Y����=��t��}������I�8�pj��m���t�@���+I��R�|�T�9P���N�L3��,�%�y@(���iW"��^���������sE�0��~`��Uw��L���d]p�C��-����b�_�����c�������ls���u��u[��O���'x����]c������-]�\�r�G ����$��cWE�`VE�4�
<�K��@��h��H����C~��K��������lS�����dG���Pj��8�O������kXC�f=��K+���V�O��<������������5Gk���VG�_��1��!���>�$�vG����9�]f�^8J�|�Pc?:�t)����Sr��m����J�Ibr���I�����c��������-F���K�*I"�R�!������9/�G�����.N/�tE��	K���
w^|S�I-!t��m4�1��2�o
k�9���z|Cu�X��
��0�����b`���j�5�V$0��RPx�U��1iW�3�T��_��9���
��a���>����p��`�4h8����#���qrC�$�|4_(J
I�1c����G@����p��i	�= �52�y��,���u���L�q_Q�G%�<Z~9�� � �j5�����i���H�Mrt7���Jn��	-~iy�0cq���o+�!;��GA1gLQb�(+)Z�K��*��/�cFdJ��[,.^�r��~|�����~;B/
 �����3M��w������p��
%�\>�r�{����C���@���fx�xG_��Y���j����&������<��.��y��X�r�T���@U��tIx��w��@�Y:���S�Q������pp!iK���FEw��IG)P�Dr�����d�Pr��Ih.��/�o4�Q���EO|��X�����s�
�������!Y����By�,q�c(N�k��5"�S�+C�4#�Jm{��|<hi����r���3��"�2u�l$�!3��T���*��6p�MHF�����:�g>�#������ y�@�!���C@X�DX�)�
K�)����kC�)H�'~W�.���I����+ �iY��[�
���cx��#�@q�#
�x6�0z�4S�o_KX� f�"����h������"d(���h��.1��n6U6z����X}-]�94����d�M�Q��2r��������J�#g�E��e�[��>�('q���7+��

9[��/s�����B<
*�[���������k���]�D;4�b9���p���Wg��"
O8|����\��pK�a���AjCO�����DP6)�y�i��#��d@$������?�l���r���7�	g��
�h�O;��T-:�}0ac��;�C�U�gQfa��CA�d8�	����[A L4�6V"�����e��.�Ai����#���GOm�K	���<*����8s�"�����!2�3 $������G^\�y�M�����I
������
�Y|[��IA ��������,���Q���F�g�����a_$2&���H~�P�@���	2���`L�<T1i^e��`�a	�Z������7�/�&�@�h;�:Y�l���&�3��5���S\���p�v �ve��@�����������]���%It Pv�fC��B��1����m#��t������������_|���lga�~$�����<����$���0�s!����r���a�d%����'��DOh>�"�p��������P!��+��yb����h�eMC�?50��NC����F�t�$�EN# ��4��G�}�)��>���d���5rn.C\���Ad�H�\�*��,tT��u�V�\0�s��\�}���������rAO�A0�m����TZ�-L�L����8�@J�1��'ItlP�!��M]���
}0���E�
\!_�W��a<���S�U��7�Gg��h	9)X���fE�H�o�|��-�w��X�&$l&��
O!�u�s�};"��������J���7K�8���JE�����Z��T�������)8�Ee������j�#(���J�����w��;����`DH���iwx�nt�W�Q$���g�&��E��Q%���_
���p�;N���}�	�
�?+��:�H��O�����?� Q%F�.����I%�EY���,����9�;����u��F�������D6P�	I��$�"C�a�����=��u��$���@J��[��Y��-L��=���4;�����#!3S�$
��U���3����H&�z�cHXa!T�<��o��P����C���J<���H�`) \H����gjJ��g����pj���B*{:oXD���i�+# �`�`��������}�%>R{kE��2��u*4:z~�k1�?�����+ ��F��  �)�\A�[ll-LM����M'�&m�(�W|!&S+B����4c��y}�B5 �o3��zb����+���k$��c��.
F���U��h)����O�y:��K�y�VZ��3	o,�J��:�l���RC9��i�3���������ba`�bD,�����`M������=�H��6y���Z���ZH�b`��;t�����)q�\���w���_��N�l�#�:���������b�����e~�f�<Y?����Y'����'���^m�����T��k�q�-��d�?�5=��A�����w���'��������(�W����������g���*�p�D,"
�V?�n3��	���|u�y�����[���k�	����U�~��/���vn!��T��?_��B-p)�i�B��~H�o<�,�$\ZN�D8�4��z���	Eb`�l��Xena��)/`'2E�5YV3�Z+��[=��u%��W�r�>��q=u���v��FZ������T���E�,���8)Vn#Z��.$B��O���C�����0�p��S4=�JZ����bmE:w,�D����lL������
9�=�#����z���^���c�K�.��gP��u���.�&�vd5O�Y���_�s>cA��~g��D�j,����3�{��tP|��2����<�����N�����4�/�?6�+BWo �������
�����%=���M�T��y	~���g�R���z��o�����XzS���������f��>��Sn�X�!Y���M0��
��E����x���P��Jl��T��������vv�z+��-;�$-I�L� ;��L���������]��6q����� a�{������ ���<\.#.�[�a}�n�!�f*��r���^��Z���������f&��R�`Zb���#r&�5��m[�n�)����Mc�u���wyE�^�=SK��xY��B�K���K��R����O�Sx�'w���y��z}���q�����R��E�\��'����j���	:���C6�`��3�����Z���$/�t�����~�-wB���.	��F���2D�)b)�,p>����%����Sv"�"���p���P*����(����9��>&���Q��*`�*H��F4���N����rX.�M��w���BDy���z��E,r��P�H@m^�v���@�h{i�.�q��|��(������~L���)R�A�_7Su�eI�!����<�@����mTH�@�5�����b����v8�������H�Y�����`��>"-��[X���-�����.2k

~L{6b���5�C���l?��C�O���r2a�5C�n�1�c�u�t�-��F�t*��
���{�MXnp����>���kI�����N��+��?&����`IJ���K�J�P����O��9Ri0�l�"��W,
c�lT,�|LG&���H�,te�S�l?�,C���a�Q%a%_�'L��`/ag����0��%������w�^�xl�X�$��L8��������E4j(�S���J]

���x�3{qiC5��,�ld"S4�z���*9,1�]�12���T����j&�v-�^��_�q%�EV����(�KM	�����7���99s8,P�aY���E��!�1~?l����uZl4A������MS�l���/�1'�[9��"]����AP�@�j
i�#\B}GoR�&w�,��PI��i�������v��+���Y��#��B^GU�E���Px?C�G)�^/m��������.@�+���b�%;?y5��R�������'��l�D �B�Z
/o�#mj�� �5���bU}$5w��P�U��]�-��6#�>������K�@�����*��6��U=��5�t<��������K��E�s-�I(�GF��8��8�����H������}F���
��k�_����W�[�I�������7���r�k���uN:�~b?�x5��5V�1���oEJ�p�����FG_��T}29?��9P��/K��[����������f
���~�k��g����sZ�k���Z�?�����6b�������4��&�Vg25�I�����?Y��yi�^���P�G=\w+�>?,��>N7��P�����W?\5�������������'Bn��~Y"]]����e��)���FO�����
�\�x�����
��~�����Mk8�m�U���Cp�������*�0����]K���m���S���'�n��,�qD*,����-��|Bp/�/�`�a�y�
��8]c���9�����������M�
���O?�U�IC�O���'o����uy^��
����;��I�u���h�F��V��M����}k�s�'��	�7m"��,��Ds;F9XL�D/DC[>���Mn`���p���en��<������h�K��F��N�- r��R�L�y~�d`�/o
�������A�|%z����N���*�-��m\ln7��jj9�3*
]?&�l�2H�?
F|�s���`�4�.�FGZy���T/x��pX�&����h������Z�7{[���9#�2�l2�P�
q�~�����!���OJ�'���W$��i���C���\�6�JK�`o��F'�ewe������{��Q�*Pywm%QB�~UrE?a���+�c�����>'&���K�V+E|$t��rz��"�	�����Gi=KqeW�x��)��\�k.�<��
�B���v���kO����e�%s�������<!���7woz ���A�/5	7L���/{�d��3�W���2����Z��� ��m\�����Pb��������;�d��lak�O�R������^����=�+�<���>SF�����I�5�~,��
����!uS�+[
4��m�Jr��C��q���]g�v��GX�$-�z�1�n�����������,���X�	�i�Tw4�����4$��"��(�u�P,��V�y�	*-���|&v*t�}�#,�2r��t�O.���K�^��b����^^<(�u���fp=�D3:1��dy�1?;o&X��}o�k@�%�'����RqU:���  �K�����l2,��
B��z�B���o���������G��;�V����c��]�����������������3!��<L�=�z����COf�>��>z?���t��P�e1oO������)�	�G":�u����[��mE���"?a���_0���M����u?�vb=���5�8@�Y6�����2�	�w&��`����e�}\�z�%�~4aXCjX^���=yp���&���������#�Bk���=>zE^�;e�T1��a��B�A[������@�l/�/�c����M��c,���d�h`(;��:.���6��"qDV]�8�<�"�sY5��C�i1�&�����ufa��GA���s����S�����H0,8o�P��x�-bKDZ�vu������tO<@n�M��#<�H��i����Uu�dj�Cj�����cP?���w�=����&�fO�����Y.����%O	7���p`,j���m�R|Q�@M�����_c�O��T���V�x���9
*��S��*�-�+�kw�+���������K�F9
j���A��}����t���(w_�l[TBH�7�4l+;w�p=�� �L��`O��7^-��v6�^e��NgJ�e���H*�#�lG���%7���a9c�@��A���X�����{
-�0�������=����	��
����q��o�����$dY�%�~�!6N#$��{�����	.�e��`)��T���-B��"��'��`%�dX>L���	f�Xb�<�lO���#�1�VYCl�#`u�`�4EU.�40t�N����|������	���8#�c<-_c���.��.�PyE��L���/0��J�cCq�}������B�<z��m����UL!B4�R���z��b�nz�4��y�y�)J����H"(���Q�^��#}�}���:������2���Okb�}��al�%�h{��������[�2�c�^��&s	���U�5:"��O�\i�d��_�'��J�����:��Y~&�Pkjz����`�i;(�[c��_�$�����������Y�!d�a
�~/��o��P@���G
��0���"�E��/h4�O�M"��w���k�q4vP	��;���M0��H���Q�{^��E�{��@�k�\B��X�w�NX�8l�	��;/����R:��`��2�������U.��5�L�s-5����y��]��J ��}qWe��lO;.�s�_�-��?�yy��
cH�;��J�p%�+����������m���n�O�v)u���q���p���8��� >>�w���"y^������+G|����#�����Thru�
r�A�?�"��w1k��]7��iI�>����/�SD���E[���e���z��������~��4@#�E*�iq�����v�Q�9*��������;��\m����S<r���#K��m�9u����Z�Dv��������c�W�������1�-@R������=���A�y8�Q�k�v�DS
+8��^1�?NwC,�W�'�yC��~X���)�g~�^[SE����o8��SQq��e~Y_A��U�3�������	�����j5o������<Sdc����U�y���
.77�-��������|�
QG�6ex����,��,#<p�;=[u���m6k���Y�>�����]�pG��a����-B�0������S�r�s�����R?���o������o����\�����nm��L���i�-�C��a�B������J��ow?z�
�U���X������
����^Y������������W��m�"�%����Di)1���3P����=<p��*�`�``��phx8`���(��88�`T�l0�4X�hp(��(r^jn4���
��
����
��������������@��������I��_�H�B�F��A'���L�*�����e��cJ�.!�/L�e�%�M bF(��$�@/��)�M'jB%�J���-k��b���-�%I� N�!�U�U�G� �d��#��E���S��Z����
��]�YJG�AM��J�Y��L��@��L��]��G��[�����������wcGusG51EmIWs33gO'SwOZ
��!�&Q|�I�Fa�V��NJ���6Y*>yrn�������<�5�4��������|�����
�Z,����~�%5�t��8f�x��V��k��j�2�L0�
3���V	vQI�I�S�r�Iw��vO��-p�������7#�:9���_�)B�2��%��3��5�}(�n8�q��s��o@@@`XFr�Z@RNJTVV�\iPryxNSR\QDi[DccZyWN{uib`uVRsND{^BiQVwa`WYRgeeX���rL�xd�bJ�@N�PJ�Fd�~R�iA+��w6e`$kh5s�4g��lh�yd�{v�h��h��v��|��m��k��}����e�*b�6�ws�D[�rY�rK�bg�D{�Po�\O�~s�iW�R��h��~��`��H��t��|��B��T��R��z��A���t���������������������������������������������������������������������������i��#yi1a���Dw���c�r0n�i�D�y*�����_e�0z��xA���H~Rq42De�FR�/��a����((���V���x���"CaF�!I�~�������������
Q74	S�8N���w[S��������t��24�B�:%������A���T%[���T
�m�5�[V����3)�8<��td�wT�x�;	�f?|+��@��A
���o8�M������*h���O���D���~����mb����F2��hTB���b�;+#��.��A�����,�
%������<+�'���&����\Cv#��M?�n�U_�D�xH,��R���\����C�����{����x�\dy�.���i��P��
[9kat�}����J�
n�S�T����NK;���E=�
���4vT��:��������U9�
2~�l`R��Y[���v]�P�:
����flS4��I�d��K��WiK�00�7Jp����1K��s*��Y����-
uE�|c������Cd��EP����@$��������o��kT	�P�����L\8���F
��d]S=�-+�|�S/I���3[�W���Z�j����mw=m�:��E��i��L�f���K�tv(�����k_]��z��kmh�����Pg��T����a��*��<K�O0
h,�r���u�!H�%���L���gO�"�My�p��'����P�c�Vu�����
��
�S��gU��(�LFK%5����+��'��dQ�WOQ�.���J��
``����2z0+T�~���������Y�!n���t�/F����s���r`��w�VfA�,��N�z���!�X���w�o�B�b����V��a�k�����S(��x
�9�#�!1'�+�B�a���,g9D}�������������0X�Me~��XV��p�<������q9�fvx�B�2w�**R*H���\og��{$�<q��O|��A�e���4�g^Mjl}�p�VT��|��]�]�����&le��r�2b� T�O���0����
����EX�{�7���#�4���
J�����@��� �5�"�A��8�6Ii�=�&:"KZ�.���T���5��K�	���g� ��ws%��|�����Fm����RXhz�0*���������c�,�ue��b:������?�����P���M,Q�GE���-�>��������S�:	z�[=\��S����f_v��?�8��[�7
x���1�����(���#"q�F�%�f!�����$<ep�
Y�#���.�N����M�X8��A��L�z�l��
|���p�����
��:�a���mf`������D�g�	�����&�z(&z��L�S���\���l���
_��'�y��OH�~\?���p�Q����2�������?��*�����~[!�jUY�V���=Xk{���;��JY1�
��e��(�2��fI?�g���fM�����1R�r6�nN3N�|$^#t�_h������'m��-UL4���S��n=
����/-���61i�}����9;�Z��4�L�l3D�����@+�a
����Q�y�V�������*wJ����	��DZ<.�/�K5>I^������a��R����y�����dw6���E��������=�%�{a��J1f<��(�����bB,=��|��N�K7�/�L��N�m�}�@��������aw����
��e��K�-j��%�X�=��sk]P�Cy;qK?^�C����q���B����>�S�99�L�z���+��'�(�V���j#��.eT��{���g3\���y����bdZg�-~E��P��o6
S��/�5^�5��SN#*�+������k���l�����U�%������Ih����p�Xi��I^�����UY������G��=�������Y#���(��x���a���A�O���S�FX9<��zw�}T=�}i�����
��E��ItT\��`
$tO�!!J^B�\����6g*����Ck�i�����
mq���z�|�	�&g9�����w�p�������<�?�Fv��"�v�uG���x 5���z�eL�{�����}?
�)�((�Q�V�U��[���cd��Eu�{v� ���BZ^E3vCG���J�Kw_��P�����;ecu|�\�>%��<��e�z*���U�h��T��@0Z�&�#���n����G.2E9��2I	e��*d�|~S��]�{vX~(,�A�@p�F�����*��b��8<��7��q�����v�2�7�1��7�2�^H��o-�:�������-,���lJe{k����R�`����c?�F��a6dtO��������pA�	<�v4%��
�6M��� ��''��4�M1�����$]
����'T��\> 4�M{�Ud�8��L���)@�fE�,�����mj��b%�N"�+za���Bq�R�R[3�n�:���g�������]]�1Mn����#�����6b�T-�.�-��`�|Z�[�L������n��+�Uf����S���>bP�V��X�w5l�Z�Gx��>��y,��#�
���I�u!�5������NM&�����:�F��D��8B��t��:4�,�
�#C4z���"�W��u���L��?(w����M<X�@p�wB�N��;w'��4�	�5Xpww��>���w������s��~���������z���-n�s�VT���h���NR}cI7{��OItk�!��E��{��D�����{��q��(�S�<�=���G���������x!����?�&�)����9���v.�!k�`$r��Q��ZF��D������9����N+M��6iM�}HF"������l��f2Y���t�>.-�3���H�y�]���X�	�a��L��2c��GjD`���d:8&/T44F�X�y�9Sj_�5���?w%]T8�at+����V�j���e�"E*_z�X��������}���`<�`�X���kZ�4�R�
����j}�M,���������/k�FA)Y��P����cwC��>� �|_��Q9��8?�%���[@0+%$l�~�����4o��:]
�W`%*�y�D�V��_J�h�E�Ni:q� ��
��'?6T{�|�R�.�)�T�
*?f��j�:��YlB��;������ldT����O��/����}��=�6
6	j����.v�t�������iA�O�$������Eb#+(��������w����4
s=��W��D�T]Q�&�p�@��pO��00`������f�T���2���eoAd����� Y�z�����+�h��7�����������O�:��&P�u��������H0��c1�A�31'�������y�����=���e=�d��Q�=������W5o��7�byL����[���c�t��_r$#Z�>�����0���1]�p:�����������?x%�Q��8�ZZ����?�}�A}s�����rk(f�<��J,p�U,�o~�G��/��G��3�Mzf�8����F�@iY������VMY;������ =�y��`�M��KR�\��z0�����)�[h	��r���.L��R1�����B���-��r��w��B�Z����}��"cb��-Ac�D��EG$����.���M��C%w��_V6��\n�E&�0a�l�J�_
�e�N����s�2�-��]��h���-�0������������.~���u��.���Y��c�NKx�N����������"�"�
���Or������h�W	��@�y��(�mdK�<�U�]���8����+�����Z}�����?��I���E�#Z�	T���?�: _�Ev���K[���{/�I��Wkl�j��y"��\���G�8���jSt������j��7�zU���hy��{��N���~���X�����0=��&E66�iX�(��J]L#�C
�3���S������E��3���(�����g������?)T�����;*��I��|C7��je�
����m��Qmq�S�,QMn�e��0�kp�� ���+y:9��.,~��C�(�Y�w�Q�B9��)R%�>��p1��U��g��|�hN#�iz���W�yA�n�jf���*g����\sk1��/����L�r8�hr������ ��fyo��������0�dODP-�cd���_C(y;0�y���<���N
y���7i� �I�0'�/C+N7�U��o��7�se �+SEO(�n��1"�&�K�����D��r���������������y�=/Y;"e��F�
�<c8E{s3����"F��^��`uK4��/5��3�MH�S�?�����H���Jh7�i	�s�/�5O[f��"�1m\�|I3��'�&����
��b@g�����N����>/v�������V��Ge��4�������`l�����?���Gg~O��T3�M��S;��'[��O��i�Z����U@�S~6��R�G������P�{����I���<�?I6����~�iq��l�h���wW�18C~��v&��C,[�E,�_>��<[$�?���`3�*�o��a�����|`t
r�$
"9�b
�������wn������d�o�v���6�P�|+��K6{e*�z����0c���`�����Los������p�i����V��l�3Bsb=���dsW7�������~���&���T~	w�d��Cp�g�zV�	A+A����|���6��
^`��?���)��x����Wdj,6L�V��#����S���.-7�!�j��t��[���G���SX��ZiN�����5����Gx?�2L�w#��6X��>�v��4����ov���
o����
c�B���������������57
�Q���D�27��#~�#��������������?��n�|,o�K��O������G�J:s��e�YX�nT��_������!���>�t~�������Tu~^��������u��Kf�������o����* �����������������M����tJ�m��w��O�X!�49�X�6R��|���.������L���NM�'��(b�*�m�=Wwoj��v~�J (���� ��'�5.��a�
yh���������5��[t��v���YG�[l�muD�q���o����k�1BJ0���bl��(�az NK�����F[KU5v��^&�z�52
V�C�
byn��7lG�t��X��J�u�oL�r����W\o���9�&�`�R�8�}����u�lg�4�Lo����b���T�+�����MOj��'�����g�p��{>��8�7YW����|��#]Wm��fcd�v� ��p.�Y��<�7lUHay�L@�hB�7$�,\7w�weJ����4����8)�����qQ����� R*�V����(�p$���T.*W
���
�#������Ab�[sJ�j?�B!���������	��3�8��T�n��Zb?|�4`N���_em����"g���xE��2�i?����7������P���`a`�`��~0�<����?j]t&�Lb��n��li����!H�D������l�Q�6)��
N��8
3�'���'�+jZ
�wl�9���b��q�������n'_�|��2Xv\l�~,��aHN���s{?�w�5��<?�<���_]�9����g
�?���1<��Ue�bF���g�^��������ow����f/�����=|*��~�=�W��~�^e5}�$����?��?,��.~���tz��xq��9���~��@n���	������D����2��Z�����t
vw��vqp��-��^���j�of�~7�x�t��v���<�Y����&�����D/��)�tH9���[��_�w��=���h�&�/������V��
���s }�1���n���x��������+��u3�{�������He�~���o����?�=�Y)�������;����a�����}�=;�E��F��Eq��o������F�k�1	f�6q��'���O���{�1�?�
>�J+�"����D����/�v�N��
�G����IX�2�f)(����i����Xyx����m�!?�|j�v�k�}��tus��|�<�'����Dw�w�����X}{p����`�)J����K��jE�i�(����1�BIImh����!x��������Hh�@���v��������O������#��������!�9�V�pv%��NU��9Re7���������7���������f��j��M�B���0P	�hJ�%l���z��:$�g}g�����vr�p��=2�lo�s�Lfu�������*��T(�Vv�%J����Q����Q6S��J����V2kMa��5��������Y�+���������}'����-��������p��E������-��G�@�?�Q������������F����������$�
�T������0Yv9�CW�fr��(t?�����7���|�����H����.^]y�����}E����>��������
����=(��#w����O<�rW3��PqX����;��K���k�\X�����=���}U������v������+�ga�v����&�4��A�pz���s���3�;�������}���D^/z�����m���5�K6�\&�\���m)��b3�p�����kE
���|�n��w��r=��/�B���Ik(��p��7y�\�CL b��������$y:�#�R)�l�|��s���&�Xv�hB��D�9���\���RLK���Lv�z[�a�"��K���I�]���]�v�����L*d���CN�]0sXK8�����]7C��{6�as�rX'��D��F�1������]�\���7?�n��In�!p�t|;�Y��Y����\�?��;(S����g���������<��D����$[��1��(��q��u6s�
j���7��mY#�������c��M�.9i0���qn����26�������x��lz3���G9�X��E�m������j���Y�A��;���Y��z���d���m�����=-�H�����N~��^��G���c"8VT���9n��i�����O��%��^�?o��<�9�2������B�����=viI��	���w�FGO�OV����<�N}����I��P��o6�/������U���3�!-D�����w�Zi�V�_��Y���u��"ZYRcw��I�+$Ae�k8WV����hl~'}�|�����7�J0��y�����g1o���0k���0o[��oc����Dn:���=n*�u�uX��<]���]�����x'o����l�_�=)�k��3�$��jk����d�C+�$�bTBQ��}�����B� Q�%�q%|�A�i(��8se�v���Ns�|��b��"�A�~���P����s�Tr
H(��}R��a�(�8���U����h����������Xk�rVG���������k�\�����L\3i���g����}��3�m��
 `��������'1s���dZF�����>�~��=���*����%�����5��`��u
�i��\�9]�Db�L
K�X�.M;�rh	w�b\�a�>:�C/�Bg�_�����9���|?�j�����;�cz���Kg{2
�q���5�������Evu�	V�������u���A2���N�J��~;�R����K�����2��8���E"S;t�8�!P3�#F�b��|!l�Wm�-pk�(��������j�JeJ:���k��Z�#6������8cm-!9FLA��1x��A�)Q�Z3H�Q)�����F0�U����!j�R<r6X]s�
�~�A���<H�M�@h�T�?i#�z`��PS���|�,���)����
�S���E�"
���������S�IE`>(���D���s��<,�\�W����3[���p�C+-��e��[�i�����:k�bf�����gN��y��.�i.K:U��{�Z���1��~�p��{:�� ~&Mi\i�+����W�x�Z
W�����p�v���+7��I�
S�L�A����G��h�kb����+��@�_D�����r��L?'N�=�G��AtV
�U"��B���7�����������,w,?�,6�m�[_?��?&Q���f�B�+�f�#�ez�����M��6`	����{�]���f���=�+����(=���K��(!�d2-]"����jG���^�	�uHM�8��T����`�����+
Vc��A2\N/�9D�:�+2���r��C}��(�A�*�(<c���k�����1��
�i�+�Pc���W����)�~/���� ��7�/=�iGs���DF��w #(���h�E������^Cw�CEF��TP���G����+���[$����PG|-������=�t�\��"�o�j+�*��R����{���j&>�����������t��{m�8��u��%�1L�����e|���_�4\!d����s�����
0vScC��aY�p.](���5��R\���X�D�8�����/��q���_%,IL,�Z����
���
r3�
oq�'E��
u_jh}��%���<>�&A7�8,?Ay���|��&��L�qgQ����J��+A�`u�L���#)r�~TE��E���X�#��aQND`@��"s������OwI�H�(VPH��bgHKvm���%SGC_�/Kw��A]�=n�x�A���%�jDgJ��%�3iW�&���lA�9s�&���p�~ �QA�r����f��fj�-��P���p&�5Af;9��D6-�T�y`���e�%+���j0��p���o��`��:���@��9�f��k�S���, %lr�/9��r�>[����#����Ms��;^kuB����]>�.�+�J���M���,���PQ����s��
������Ho��QP
�����x.�k�2u|�!�����J^��R>��8����IBp��#���#)��:#��G���[�`��B�D������_S�r �"=#>�!����q��S�ofR)%�$v��o�D�e����C`<A
+�@�'��5��j��T\Jg�*D���
�7l�H�+�2rj t��y�R�B�<�i�4�gJ�z�6�����B������4z
�[`N>����X�[��`2z��1ZZ������P�#���c�W����m�!H-R�,����&�L"�������"Hm7���l���R��+x��?����������.~t���X��������@��CC�po�����������l!7���������[��*�����N�
:��z ��*�_(�U]�"��/b(2[���x|]�A3���u������37l���������-:��������c	�8�c;��=��`�+D��f���zaXxs;�C�a9�������~��$��P�qF9)o��E�fX���Ok�����`|���5a�vbeA�]]F��$8������"������E�����M���P�3�Q�
x?��:�������U,T��@Pn4����u"�?)Sa	|�8�i��s���'��W/��R�.���n@�k��w�6p�?��\�����?-��
����4����
�6[s��J����P���rb����%��Y�4@��p��4_}lFS4�Y���4��o����-�?�j]61�wLk��=�����9Q���c�����:7Y�H�8�v)=��w��f~T0��a�/�r��\��H��4q���@�:�j7�G�*������Q{H��������
�C�Q)��E���B��>���=�]�"���`����:8;v0��g�Y�� �\W{c='P����tjQ4V�Wb�-T{u�������{E�g�!������J��}H�ch���?0Z5
����(2���{A1�9���7����{Z��gW��.Z7=6������4�����5���J��������	�������(��>:��!�Z
��Sx=��+8������eK��;�� ����V�r-�����)��B��D���������#$l=v��;x�7�Xm���-��R[�[$o#�gE��������^f���l��~�}�"���w[�G���Y���

��D�Yv$��CQ��8�Fc�4�#�<���E�4Q�����'�Ho��^zU�{�X��J���p�I*�9�]��K���=��)��/y�Z�<��S���b���F���Uz�i%��M�
���T��s���	�������6�J�zGh��C��|_��1���~���P���*@���+O����q�x*����A����o��O����j�(_�o�a�F�J9D����
D���/�
gBM���Z�D��(r�
5h��� 	��W��M��pTn��c�?U�'�K6���[���Xqd �����-�5�
��e��'�
A�T~Z��$�*���^
��b K���^��F��z�D�x"=�����F��f��+8�������t�D��&�_�5���u
'
+x�W)C:��	�-l5Hf��0+�V�Uu��n��?w��F����0^:�E_�I���u+�(��	�O�V{]��?es��D/<���S`M��S�
 ������{���xB��&@S���M��uv6`��(k�T
�p�}%���@�g�?�!	S�)CG��:�8�#
�@�f����*���kHH�|4���
�n�[,�W�%����7*}�:�?.�u
h�&����^I�W�Z�Y$F�<�X, ���EC�>����:��'���w��/	%�R���@kD���
�����fP�����!z
CX�Gq~��8U�@���E X�=�d~�����z?�*��H�6I�^lpB+w���?2�K��e��FX�
��%]>��R5��<�A4>��*���)�_W,��$�A?�����x�
�����@sP��%r���~U��8YCrs��*�&*Y�.��Vr��y'<]���,�
4	o���U�!���s���R�g6��
�!���E��� �@��>I�&z���"b�'{9��*�������RSM���)��Iaq+��Z�<1�0���B�k�����
�*�v��������"������+�b��r-���^>��
p����� �Fr��z��Mz~��S�6���
�:]�l^g���T�m
�1e�9�_�8�o����T�"�{
�
�E+Z�aKv`y!���tCie^c1�k��
^a������>����������T?������R����U<���Y�UA�.�����4nn����xX���i)�P��	'���D3���|{
!��D1����^�1/Q�D"B
;7�@/�k��y!�#�?��-�l���2hG
�W�Pv����
���vb��V�6`h�V���*$���A~
��y�����li�l����U�q�W�ZZM���y;�����J5���P�)���"���:�����z
���n%)HC0��Ok��f�)
��K��Jm���e�D(8*#�M,�X���H`]�2��d���=�~	W�J��_��:������Y%6yt����g?�?y|����}�����b�?����g����$:;�U�;�1���V�]B5��A�q�*2�������}�)����\"P�h�g���G��op�&h��y���.���'����j�VQBxi5�uG2~v�v������{�E����]�j�J�=��}��~u,-@�X���e���Z2%R~�@I/xE�Nt�.
Q��Y����I�b�g�H���b�!82Tx�F����;HX�����L����i�5V�X/J{��t����T&����1�:����R��@	��S���%�����lSo\d����jc��3^���O��
��]i��\��:�hv��4���z^�����	��A~�X
�n���&gc���&(����;��PEF�l���bI���}=�7�s$��'G
%�b�@~W]e��p�A
6�a����4XvF��GX3c���Q��G���E)d���6�� ��^��p�����e���*'"���xG8v7�������/��M%"�b�5%~�,@
et��|��)p��h���z<���$v`c�Z(��IU����*M����p���r-w�I���-I���,�����3�Nz�>_H�W_#��,�o�9f�'7��/<�������O��������l�|���|84V�n�	$�/�W�\���=�4��%7]�*�����g���9�|v%���
?Ym����������k��;����3���f�w�FW�s��d	�_�{��V����)��F��s������WgZ�G��g�����)�����������	N����q������K���=]cH��KMJ�kd�#��9��j���a([�'�Q�}�f$�9���Q�S����9������H?E	��=y�_�RjvE���r<byz�P��5��%�k�
{�y��u��W��`zDx��=�A�_����U�|U$���d= �2j
?�:]�n/?�;=��.��u�Q��=3),�r�gf������bu�|~29p^�wA��nj�g��k�l�Q5<l��y�ka���n���\t�-�v����1�PXq�����}L�N����� �p�j�3NE��Q�/��HiC�=���;�6���K8�TaH�pN���v�(?j��m2�>�?���*�*L�jO�����������D����^;��,�0�W��|!���6��c��Q�����k�j
�Z�=��ZB^�������������
J?J;2�.g�<��U���K��!��,y�n�(�r.�&8Sd,k�#N���i��E����.��B���]�1�a k[�y\�r��e?�����=edAxuE�
���������~i�
m5t�}7�3j��P�y��7L`K�W����\}�u��:v�~�~R����s��� lH8���u���S�!�������Q���
��7�)�����������j%��f�������#tqz��	c�S�o��p���HI�_�JSu���#����g�_na�K�>�-�_^�V{���n��Z��Y�#�>�|�2����{���5{�������MHy������FI�����%�W�X��������ym����2��5�>g���_��=����4%v\�������L��9�����E�������
�y9���Lh��������}��^p}d�
�����q�==�IY�����L����aR����M���R_}�K1n��Sc���y58�m"&��������E�M��~t�o���k�#����#������fcK�K���ksO����9��Gu;H���n��:��
�E�o��0lp
�5���}���}|2��odT��Zf�6�}``;SK�"zw��- ����h�9E�� �B�(�?AUe	���B�p�<��N[�z�V�8������
q���v�D��+�������.��x�������h�����gx��Y���%.��7���^�r�	9A�����B��H��opr���Vu���g���M�{��&�����c��0��F�^t����������b^�,����g���k17f������w���e7��`$�?������X��_����'+
)����1FC�A���on��ow\����������a�Ap�8�3Y������T�(�,�":n���=��wh��(]��P�8u��v��n���{�B��q�I���������At��1n��i�y,F��H�M�A�,�=N��+P����uh�����r�@
�l .@Eo���w���]�����{Q�B�E�|B�������.H�=��;��]�w�2'���"��$K3����wK6kc�!8	����ZT�.�e�'��	���.�8G��s<�FbH4�i�\��_����9.�<�5����"�Vem�M�3��(�I���rE �-"Z�����������J���FK]����D^?�~];�������$$�]n��?W�L]nP�#drx�4��!�X���.������/��4�����q
>7�B�UqB�������*w���|�ar7VE��#n���cn�%K���`;;�m?���k��Bv���Cyf�����lQU�dr����c��������cd)*�A4�'������O���w�$y]
>,�����/��<i��D De��A~xO���`���g����s�W��}�^�7�*Scl��}n�I	5���#�l�>p?��K�	���V��X&��I��K��T?2���>i�-�u\-!�u�.5x\U��8vEV�$�c�a���WS�Y���3Cmq��H���]��)���Fk����������0�U���e���)��Y����J����7����M��#�P�@�9���j/�,��#�����y�A���������6
�
�_&��N�X�/�u���J����IS]�k)�2)��0���?��KOx��C��������M�e*?��U�/aK�@2���������=LN�|�VO�<B��sb�'(�G��8*�?���4r�c4������V)zX�� ��`��l��T����q����y]5r>l���i1��������K�2������&�?��E0�Y���w<���e��u��	g{�o�����]����~�M�����@
A	L}AgY���0��QL�d/ffn��}����vbC��B�q�����������-J�'vMsIt@�������
g��������"J�
�B����}
�e��k��)y��R���nFZ�.��������������W����b�F�bFUsF���Vz�vO�J������d��O����E��
��?���
+��8� NM�T����sw_�B�?
y���aN(G�`t��N�O�����{�\P�k�7�<�tO��I3�dF����s�O-�`1��$��������t���+�[�4�h��t$�"�F���I����B��a�#Q���x\c�~0�,;���F�CU�<�sG�
���AGm�_�{����p����{�2@Oh=iDEIq���L�=���� 
��*�Z� m��F����mY\��M��p��r���o���^������r>e�7�U�R����!V�Z�����JtfI�z9�F�����z�
b>"���]�����.9���[q�"N�����{����������Qpze�p,>�����������g0���
�^v�G�f�<�q`�A��AZz��O�P6�.�*;r}^�+�4
���L�v�h`�5���=5M��~�����m�����. �{���b�_Q�
��	hh��A=�����O��S�����W.�G�c�P
%���
��_����nL���.�[��.�
�;JcpA�-��-n�'�����Fx���*�TzD���oz_N�!��d�n,�����H��P������X
���neC|���D��������UuXSg�nY�?����!st�t6�+#���p
&a�
D�pe��w�`�����)�����!��+�,2h�E�v` -��C��F��~�}-�[y95Q�p�6{��]^���L�y��M��!o3�������^?<!����>��n����T��3Coe4�)����=l���-T�B����a���2�w����
��$,(���
��=G�_�Se�E��*�@to
�A2L!�g�YGD�?�9����#��mf��X��n��n�E��A���X ��x���U�����R�����^�	RC������H������z�3���
^��a�U'M���k������;���,���?���1q�F���#�E�_%��c�SN�����L��uv�����c����!P���0J
A<�&�M�)��y:�������
[�=��j�*N�	���b!nR'7[T��=svU�BN/���f�cT��D��++����8�|�����,U��@�6]=����v�O]���G�$C�
���l��g-$f3���Q^:��zv'�O�>mR�N{
0�j(l�O���y
�>m��������W����;����~�N�.��0���8���/�������!�C�LAJ>����fz��|��Z�}�db�=����Z5�*����Dup����Q����$VM��t���8H�B�X��t�}��e�\�}��;0+����-k�z�W��D�����m���QGz��)�j3�S� ��j1�Y�9$	?(�'J����t(��i�
��y&?�����2f��3E�����lagg�E"B��y^��Xm���C����	
^�����:�7�4�g�������/�3����C�f��T�@�~a�%�����b���6�!�m��f��29�8��t����g��p&�am�o$����w����A����R�!Vl!�Yn������-��P|a�c~	�-n�����:r���7���6Y��n����-��=��$����]9��(ZZ08��C�k��)E%83������e
8�s=U
�x���:d�H��I����8�j������r`�UZ
G�)����d�K�L�`X�p,�0��3��i��j���ZPA�Nf4=���X���a[L�A$��3����
5�����\�f����c��jd�a�fH���3�����+>�������i�����h�����0����h��MCf���s����"a2�FqGUj3�u)U���1��7���^��N������o��aj�A�y�0B��y�k������@�d-k8��L�m|{�YP�moI��xo�B��O��h��S�z�p���(?g���Y������b�g=Ys� �7���q���!D��������* �iF�O%��N~R���i��
tBb�b�:l	<�F��m���m��0����H�5*r�A�����[�Bi)8���Cp+Ml��c0��=*;w��p
_�4LVr��k�r�OD6��L���������C��W��(�����{;�����Mt����&J��40Q���jf9R
��br���a�dV��d��vR
��8C{.,,��g�l�2��,�;�^&�����S�b����t�g��c�[^����������\j�O�5�r��%;�'=Z��E��7�
��^�������r���E���S@:/<z�K����O
�����t��ab|��
R�>����*��|���_�L�R��Y4��e^,�����g����-\ja�"�XE����f9��V<~����s��S|��)|��:���^7O�TY�h~����=�g)� S�F(I�;���@16���?����B�GS.�Eufq���c�����z��\�:���i��
��"���c���	���Ra}G��K�6t��qe��:o���/R�������7u�t�Cb����$����S��7El����MU��"��O�'(�������G�tZ u�JU����w��+V	��b�����3����eT�;���E;�&�h�+*@#b�0����'�������$
dK�t{MV���q�f)��oj��_F	G�8�E�;Z��u��B�1q�-!�����n�����On��d,�K�JF��~��~y�~�]{�T���R )����]vP��>��B��\��F{�#����t����`M�+����q�c�v���s���k��o(�yG�g����� �}��%I��!�G�A�����Ahb�s��M���q�{�������h�A�|�#���
����>b.
��?�G������	������I��(by��}k�������#�T�
�F5I��:�;����T��P.l�����u+x��"��9���d~y��� E7����S� �W����}���[���������
��'GH�=m����7������oH
��>����A�&��������S���w�0p�o�(��TQ�M`!*U��,��)mC6x�6�^���<���9�YE�6���A/u���o/m���������S���������i���
���g|��9~RV����s[�k�]�[���d�����Q]Si_����m�E�%�V
mD�M�w��YCBGd�I��O�=�[���GIt�H���|�'��o�;'�T=�+_~	g����6v�L	����I��
�������s���[�I�WV���ow���CN)�]F}����T�bz��������U�"/z,������|�ql��Y�N��vmi���#�}$e$���<��m��=1g��/�������{"{"d�V�-��'���r��>�������'R��t���}�=L�;��T�X����^:���!����l4��l6��R��
]���}=&�V�mO:������k���������e�����W
����I������uH�]`'�DP���`�S�=�hV���������S$[E����"���_�w������k�{���i���F|8�t2��l��g3�J�
h�{�hL���%������rgg���ox�b��$����}@����^is�wqr�����(��JZ���=���#�_�{��	�9���B�*��n�G"?���aG

W#9�z4�NY�	UDn=��%
�^�D�2[�82��.��]�5Lm����"�3�"O��J�[�JFz�f�{��vK%^/?�-��SE�DSE��{�B��`��L���b������E���E�"�{����A���'�6��#�LjS2IF�3��yW����Sy��iP1�L��f��4��t��G�vB�=�VP���Dmvy������b�x�PL���	����y��>+����l������9��7!M���6�<"E�ER�i>��\S�'XY�T2drW�)�;G��+����a�����@f,�[�eB�������(��]U��"��"W>��`������paO����Q��;������K�d{�4����������C��{��lH��
�W

?�L#Cd�V�������C�1kqn��j'���~%m^q�,�W�i1�p<I���@��{D��~%)C��q�@fO�J�&����pr���<)I���Tl��U�KeA�h��M��rBJ-���e&�
[Y�F�i���L'���#D������Qr�<��,-�"4���6~U���Yue	����MS���<�'(��bl4�k9H���1Z��f��F�_/���e���M��Xb%ICsdL�Q����J�-�������-�{M��U
%��I`[��iNE���SN#�*���M�T��k�X\mM�,\a,���"Z�t��Y�E������t���;N:v*�mUl��m��mv��������|�Q?�����0�cV���>��z;[mT�������/�2�2������=V(��������c������Y��q�}�@~�K&q��k�h��
�p��n���r����k��7T�f�+&c��2�f������hL����iM@S%/���U++��d{T��|�}3UQ��:�8�uv��^��J�v��`�Ah
��I�Z���S��C�����fS��T�3+���}�m'�����I��}��x��p�M������T��B�jM�K?��l2�~.�q�o����r�����I:������h���d�/���f���p����F��h>1E��@����~&M���C�����Q3�}���?�����;�����	���R�|���q��I���Xd��ydx�-��U��wl�(��9�
a���!��X���OUz��W������+���BW���5In��aAE���A�*�)�S&�`v��vRS�D����U&DkA��XZVc5���l����_,X���r��&�O 
T�j������1O��Q<�������Ro��H�l�%��!W|������S�MASm6������w����IA�>�����@Q�7#���o���p��HU���j�qg��*�~g�<+�Ja���fh}F�g��O
��g8$�����%p��S����L�*����
�<~�x�d%*�J�p,��T��5.J%"��t
0�

x� �:~�q�R����KD���/i�����)Z�;��K�I�q�[�~�>��v�g�#0��6�M�h��n���2�we(�b8��4)a��#�$]���(L�<�tc'jG�V��k>�O�
��0�}��������TI��I���4L���7��V���8'�^�S��4�O2���/���������r�e71eF�yo�w(G�yq=��D���9�����6x�w3ut����MC�C�
;�������2����"�OC���m/�~.n�:�=��+����=c�`3L.Z����J�0m����}��h,MQ�k.2u[���k7����6�J��W�&nm~�xS��:�
=6B��A@7
�[�6�K[��JY���vH
�#9��P-�C����\��Jd�����c ��07��FST��X~#�K������F�����s*����v���g}���X���w<����T�\���	SYO{o��.
�H�����N��Ph��Ca��.nr��@ ������/}�'�aA�I9
��F54M6T�B�iZ���x�q�<���� 
��H��R��ZI^;@��� 9���#���-�5uy���"5��4k���j���J�sp8��n�A.�����FJ�Z[39�� 5��
��{�ylZ
�fN-rw����C�?�T�?���wC���M:`�ICI.�kB{�C���^��cQ��4$��������z�s���@��Vm�YWq��>�sK�n<
n]|+��@�BXa��=�HW�	�b:�(P�S�4,�x~hKP�����MX��8^��2��(5v�hp3w�S��@�����|j�,|�S� ;N�v�FT��AA?T
��)*��Jm�D�4"�A\��(n�`LQ���>x������h�z�'gX&Z��t����i�����)���qN���t������6by��??����<+�	x�n�S�3��>C��"���$n���@�&�p���4h�)����|6$Y�s�S�)�er�XD�����c��q���Yl���w;�Cj6�g9����P��f������K����.PcB,8�df�H_^�@<�
?�[������(��@�I���
��21�������V*\J�i��^v�F�j�_$+l5��5�m#�)�=����X�r]5�Z\v�{�:&71	5�d��p��%�����d"���x�xK'��Y
o��
>,�� ��h�9PPVS�J���p� ��d]�������H�;�|�i�+H>��8U��r��E�1�#<�f�<�X�5�n�G��Z<��8���c32)��/j��M�a.���7����������u5�d�h����Q l���j��x#Y!�_������M�6�fE��d����O���/?~���.-=��B�d�i��x���4��5���6M�/X�����zT�(_��x���h�<K��c�g4VT�]{�����r�fc���r{�W��5�${�<l[jk<�<,���c����$fw�a����bU�����*�+g\=\I�'�
8g?�9}�������V�I1O~�V!r�}m���`{��R�H�0�������g�����{�
��@�����3�
?qs%B�gp�`#y.X�8���BE�����M4f��:n����T=@�]���R\���Z�3�(��t�n�����kb�}Z�g��
�3��,��������]��7l6}3;\( J{���[:c��&N��k�����we���E��$~�*�P���6����*�2��K
��&���\,\4L���j�#���E��0�'f6I��F�fC�&�$�/�������(�fX��5�J��
�Z�y�3'9J�A#������x�I+�8�������X��+luGL���p��.�l(�w'h�Xs0#L�-�R���S��9M>Q�������o������G��t��h��0���b���|^���j���
��FF�+��GH���*?��6}�E2V�Q	���f{�/��^�2�l��W{��n�o�K����+��c{�U�Ojjq����@mX��v�{��k}��Uw�@�gs%f������/}!�?������o��&�������:
�%�����0l"P&����v����6W�
c�8>�
z�N�������G�V���\8}�W����������(Il�~
���BDdf����#��C7de3K�ynI9�'���*�@
�2�<JtZ��*w��}���
����e���H rz*�s�,� #S��� h$��3�M:������c�-"c���!��f�;����X1t��L��V��Q��X1�+qx���:�����!�����ya�&b'x�FcR?��G��'��y����fa�E������3�c��1O�x���_�$�P���td��'��&��������U)X���y�W�
��o�MA�����R�RaId��
���
�<������8%��w�;�5<cn4��Q�W�oJ��$����2A�����{���%�z]>7uP���/]���=b��Cm�+�}m�YP$�����TM3�e3q5
��"t����>"-�5�N������Vh�0"5|��&b	@��[�"��+H�9-G�B:g��h��@����
i�d�{�n��
�����C�4(n����#R�_�(���������U%&n&���v��9IX�������b���O��U��E=�?Lh"3������Mh��x6���T�[��!����?B�e,��c������<�+���TA;�����N�G�E��r���������m�������\C������[\�:����W�v�4��0�*������ltw��[������������P������ �0Y���vE�}p$~����8^�������e�@4���@�r��&w��
kQ�5E��a��sS�8$�p|��B�3Mt�n3��m�}k�pu���E��D��2��^��PZ
���x�����o��i|X����7�F�����r*G�)��q0�����[�e����x��F���el��{H�r�@��4CUt�����-�F-YX�Q���_c08����ryG���-���t)�S�E��h�C����I���>�m9�ox�����_a�+�q-�4��(����b@7Ng,�[��H�,����|��������-���)$n����� �M�H�����o��1�v��N�x�d3�YS+��v�8nYn�����)��ED�v#AEsH��cF����m�/hrF+��)�5s!l9�4����z�f���E��A^��_>���X>��k����m��k���^��KOB-��wg#/�tj5uq7a�zbP������h�j���@��,l7#v}G3F�`��
��y�[E��)����
V�~����j��
8r���L
�V���S�h�a�#6t+@�������.ZQ|�U^��#j����*'�f�,���]
��N�����W��u��,����)��F�]�7����h��|��D��4!$;���TO)�y�$��g��9�
q�v�)��a��
l-�X�>sM�
����q���@��J�a������������Z����@��{E��v;�4}�
����V����8����hJ��������5T 8�
O��h�[a~Ly����=���7+rYi;�}���3��1�G�@;^�x��J#%)��or��k���]��E�����g0����)��a.�U65x�*�X���q�A&�
�}�h�����������: ���i�J������&�[�2���"��",�-������GT�f;�/�9�����

�m�D��)����>a���^�Q%�*>�
$���
Y��"R_�����Wh�k����Um��
#����}�#�-A���g��l�&���5�D����ml��������I��2��8�C������),���A����}:l����O>�)��D�S	l�A�Z^�<�!pjDjs�����r�������
�,�8;jb��ml��yJ��9^r����������A��7�����f^�G<��^r�d5#�z#��psq�1Q��=�i�J+1H�`����/�������!�O(����)0�/[����p_�X�� g�1��������u�V��U8���N:�iaM����*&��]���������6P���*C�7������iY�����"��c�h����s������u@&	lz
��
�
��c�
�K9��_o)�K29���
���q?�CD� ��gt�#����x���#7%��,��w>�W��W��W��!��n.Tl9A�W�L.8s
�����+�t���k* �"�_H�\3^��"�C9f|�Y\�k�P�7�t0�1X���C��@|?Y��tks�.�p)�x[����@��Uj$�6Yy��G�e��d�;�JD�`���Z���K{����6�o$|x���w������|�;��*W�a����&-&����!���Z�n��w�)�MXR���#�����5�j����d5AM
i��7Y�����P����8��_d@�7:3���-���8h�i,���JH������t6
���}i3C���{����lpX��>9�W�F��`��?p�pG�]��5��[�%=Lm}����aG�)8����2���7�I�������Mi3H�r���2,��4�:'�TO����X��� �7=�n��e�x2�(�fY�l~2$�!$�'P�[S<�I��&����j���F��8)x�9U
6���
)�:?Z�qC5G���d���cVf@�O�Lm���6�C��\m�z�Y'�;��7����"h�������ge������@�x?P!*�5�c*���e��+�[����g���H����N��
MX��<O��^�H���T�l�&b����#R_��o���HoqE�����#��RV
�����
��I1(�sk��������*�a��J��;X�G���vs��-�r�?���A1$_�m���D��u��6Q�������4�0\��0s������S�����G�(�c�A������g�>I��66�����{�����6P�,�E��n�?	�� �l$�1O���?C����8B��Q}�_��z�z�����V����������-7��D[��!)J���a
�&(��[��b��("���:f5�n��u�j��������S�����v����
���U@�
�<�/��g�}��s��
Ko�x��).���K{u_��:e��3�C�����*�f�S�u������8�xe��q�W39(���H���������n�@���@ �T����@���m��/��UMZ��xk�b��0ERj���\<�PS�2>�
iI��������������������b9q��`f=<[��n�>�����it+
	�qC+2�"�	,u�����{
�~1��:v�����1������
�SW�+�K}��N[Z�k��#
�!
1]{7e�������V��b�q��?������([���K��@q*��`�s>I���+
�b!p���_����L�j_�@��������L��DG\,,�/p������wsx��t�
iu����hzk��&|���J������?���u�hA.��(�y����~Xkc�*�@;T�s�Q�abo�@����
��Y���@q����@�\P2e�1�IL|�Q�=�5�/���lZ��3u�������FcEfs
��w��5���#��~|�:����b��|�1�5�_k�
�}��|:��n��?]'q�~����Z?,n��e��{a����3����3����W��M90���+@�'>b}G�d�v'���(����&����+������w�<�i���L����{��`�d4��CF.���_E���1��-1�(L@0�I����ZR�~~�JH������M���3A��XR�>+u�F��N� ?���=mS
6^WP��`�SzyLU�S��~p����v����v���k���.�*�{b�]��]�dW��Hu�rO��R��pe����	�O���;�W�\��
oH@N=j�����jM��-.H��Sgl�m�j�X��RT�x��Mh�P�<w�jU�7�a��������?�,�L��E�+Y�� �z����nZ����L��JL����(b9�x��
PwW�P?��08(:�X�� ,a*%��A������!!�U��Y
�E�Rl����h(�1�B%�i������K|�E�����Y
�"�\�����c�*���N����>g�� )9c�#�Y�m��=��~��/;��(_$�����q��D4��G-��P������5�5��#��-q�`������h�=�
I�_�=`��q��^�$��b�����_����������g�����8��/R�}\�ZSB!�V�O~��J����{����k��h3����������Yc�m!=B�)?�������Q���BD�1�D�����/���g|h	�dtu����Z��8�|����{]$Y��f�����,�����������vsG�KJQ�����el��t(��^��t�Q_����?_+z�"D�M��X��>�I�{�%���������#���A�����u2~����5H��#��q�to����6(��n����y�������a�&3��&+�B�*g���/�Aa~|Q����?�WR�@��	4���nk���K:�;���N��`��x������)�I�]��}�����Z�-s=nM�u�tdwt9�n{o���~��K������@�����:�����V66m/2�2K�?t�^��������?
�2�������5���k�Nk��b�G:c`�A�`��X����
��{����y��{��y�tO���?�����M�r�����M(��H�W
����z��m���t�����\1@_���@�d=�(=&'=�
�����w~�|m����\��%���
�3{i��zi�b�v�	8%�����@��0���������e�5����)n�~���r~�n^g5������9�.X��R7Xn�N|Y_�*��E�)����&��#�tla|R��NT�����6�b�����2=���rE5�~@����}��?�t�������	U�imp�����<U������������f��m
�e�/I]��=������B&�2�[������I����Q�C��Z�1���6U/@t�{�������Y��{�o�v��h���Q`��)
g��1���/�S:�����x��Ew��<�����������O�C��M��jU�c.�����6�m�:��?7��\�;��O��?���zwz'�u.+_����po{}z�nw-��l��$�>d|9�yD��N�����eku�������gl��� ��!�����YNxk���x����EpnL���EM�������p�d*0m�������8����?�8�Y�FS�~�Z���5�������R���Mn������5Q�Df~�����vL���Nh�KZ�����q�*k����\'��J�I�.73-x*4����[�������k�2^�!g,�7)�M�{1���!�c"=���Ns�&IcUtJ��k�^�����-����$>��3��Uu�O�v�����bQ#p����<H/<�h'��V�Kqf��r/ja�}/>������������<d6a[6'�v���2�T}Z�knc�{%K�/��t�H��w�k���Q�����N���#@���}e�m ��F?ym(�d",*�,��u��[���?�+�x:��m%��������s����U�(����nu�r��>��OLb����L���#0��6as��n	���������"�2t�q����X�7^x�*����������Y7h5l����h�E~�e��z�G����o�.j�oQ.K���?r�����������d����'5��Z7����;�D����[K���5�����/?�q�p&��h��[��L5�q�E�z��9�Q�

�4��>���~��5?�}3e��E�#��M���c�\+]s�1��
��\�@�Y0���q�{��~��5iU�o
�����v�����J9�q]h���<������at�mN'���(��w�P���	�~4�?{����E��?{���,�_Z��c�'FRq1T�������o���I��jq��aE�63y�T����rb�\�����;��
o�.�B*U��}s�?L�0\��1����������)�s�V�iM��
&h����w_�U���E���/m���v���O�E��ny��~�^�����g����0�-�_2W%[]����s���E8�1J#�}���������Z������X�j��2���6��>������5����-�-���g�/g��w��K��8�����=m��1�A�D��)r��?���l'��w��6����vT��8r������+���5z���DJg���[���.EZ����~�eq(�;�gD�b
Xv�xY�����xA��*�+_��,�?�����8���{1���^�CZwB�85��h%����kE,%-b2�(�K�����
���r'�W���&��i����UI3��\�
J;"aO"�r(~�Ic
��*��?Y�4��1_���Dy�9���#�bF�?��A� ��3��\��AO�h����-�$M[�%���Ig�B��r����E�;����2��ia�Wu�����N�FEl���HM��
������]qH������]C����:E8bly(�FD*WL\��R8Bw6v-�P_�A�T��}���m'��_-Vf�D2���f�q[���>������ �s������]aV��!��j�`��e�����\�3��G-������\��'�^��\��UUR�)Z��;wD�
�8��68��y�)�4,R��X��6o�����_���K`��9s������8��x�
b�qN�A��R���&9~o��
����O>��Ut���N~�
Xc�Er��S%G�|+��8��#mn+u�5�hCpd�(�&��c7������*��d��~NE�K��A	�:|t�x��N�<��r�������[n��uf��
�g�j:��4o�t�g���L��^X�
����fk��	��&Br�{/���������:�a�1'|�fj�8���H�Wu-�q�^=�2g���s[�
=`�����c`�c��uZ����+1NU�)�ID�/^o.����Vm0v�,=����n���$s��*��V6"c+���<���������P@l��Ao���,�`�^�G�������������H����\�2����d56�U5����)&��1�}�!��w[}]��p�#J��C���
v���e5K����r��1�TD�m��Y��kI���p�>.I�$���MP��24��F@#����1��F�b�
�1U{���-c7��{�8��+�D���K��61��C��.�7��WC��)i��g�����i����T��EX���nr��g�{C��P���.�<N��q��B8Qf�P!U0�<����^�������H�����
�e
��NJ�1A.���K�����hI��������}_{Z�������j�};Bo�1$8��4������,��a9��
p�d��Ui�?�*'g ���u g9�*��
m
�y��=��q�����u��0�<�t�_�{o'RZ<sD���Ztd�#Rd$�����6i��7�W��T�O�D�#&���8r~r\�����O��`�{|1AE�8�T����Yw�s�0]��/�o��;I_j������e�5O���T�N��z~��A��h�g��[1��,PA����D�L{����s��Bp��z��>��@���K�I���4_M`�GD����r��*a��>f�*�F-��Mri3����a$��AVC�Tn�@��� �c3U$���%Da����k��J���!X���FT���$�V�j!�;���vH�:kH>�*%C(��q~����
�$����0����5��������������1�M�2-QPw[���V
������<4��������N2�%��=Ns�����{�����*���_�%��4!�Bu+�k)ll��(,#u9�����������f���������_ eK�k3�s�8"\q�gi����e���z�x����(��j�����?YY:�M;%��Z�.���.���vF����
��?�0u���L����(��oX�7�mG�!T,���S���_Zx��5%�bR!�1�|%����P�2N��������,/c�+8}���5�G?u�*���$D��l������JW�
u/5���KL�]���u����7������"��v��=Z�%�m��w�4:������q�5G3�q����~���7
�����!�����R�l��hR��EtCV���&��R����d�*���/�p���+(�%�R����)z��`�X�kQA��x��(#�k��4:%�6��K���Dfd�����wY����o������w�
��������cM��Yg`IT��9t"'��!y�������p��
b�����E0���Ue"oaB�/�k����`��	��H|G�;���a"\+M���,����esMQ�����8)��?G�JX ������q$:=��J5����p��L���d����]�VL������l��9]�x�!`G=p�G��t��+�����9Q^��fP�*@:�NYeHm=I�G�����x|Y�-;�O��4�v@>�S�����<�t��?��0-��H�n�q|�(�q�1�&���4A*�������,3�����gd_����2t���*]G)3���|g;����
�N''����ET����||b�8���.�Jm=D
UW�1�������:g����a��dl^��6�����z������/p�N�E~&�����U�������DF!-�I:@�)Ts���&1��4��B���H�(��.s
�PU�`iy�-���8�
.�M���#����!�=�g��VO�x>����ex����3�>/V���m��J�tl�����P1��9:���$����`Z�O���2rV���}��I��"�w^�|�Y6.���c��4�>zE�����Y=�FP�Y6T?�mc����
k����M/�?�����|Y���9���:1����?��{ ��
��[e����j��|�_l�����S��l=�WUl�}{07b&������(�H��E�	� �6�8[��������F2���������^s�M/�(|�(�N�h��0
v1���G���u&1�]
]J�����b�tl�w<|�S�\��K����~'��b��� 	��j�,�:	���5��r]�#��t���I���
[11��>��L��r=��hQ�X�>�g���#����F�"+i�_����+��]8���|x(������������3��{�{�S
��h�7!(6T<��+z�k�L��
95y��/R��}T���������A����IE���W6��*u�������0G��^a�q�+���t�0>�v��`2���p'co\���D��H��\�"�=V8X���LM�KIb�>���
�"���?O�����)��a�h�]�kh]�*���.r�a�h����]�������a-��r.U�mf$pN�x:������|]#\0E�I�8g�{�%j�d��������	�t�{��M���*������H����/	V���+���V�-H��M���_<�)]�/�j���q��DZ�]����P�
��H.;���aZ"��pZ��p�8�����$����(������.���>^��f�
��}�f)���^�����]Uc�bT�����6av�����5�)��/��F+���AQg7@�_`��9����!������
wQ���	e�>}��6����*��i]M���md:b@��#j��i��:�#�\���=�C�'�c��dg��{f������Y���K��@�������Z]d��
�qp���Afl�*QW����8���Z�79um�P+�6��c�m%�Q�

_Y�_�������Oi�,��`9��	o��n��gJ�:L�{9�=_M�����rOcxW{t�0�P���v����"�v�
�W
��Ae^����H�2���+�H9�Nnh�]���Ck�����P����:s�)�l���Wwk����� !���� >�l�Y�1����{����>7q?��6��R]��D����1����U$\u����%!��Y� �*\+OV�]:\h[�=��b�����k=R�(YF>J����hOv�V�	�0�2F�\�*�����k�3K�/6D�u�
��9�@�:pA�a"�����SL��O���(,F��J���_\��u��T���\=l����c����Z�<��L�/���1)W�*q<p�����*�U��%��_�a���L~���Ki����g'������KE����+��_i�������o��x1P�9�2��������1�����8��r��d���p�Z���d���a�\��(e!��zm
>���x���cYk������Q�"��������?J<�����
[����'l�C?�m�/���Z������V���6����u���������=�/���Pj���v%RJ5�;�5Arb�}��]0)�`��|q@���g5������a��P^�����)�#�C:�%��f����h�R�4�`��������'�(C���7�q�eZ�yw^K���6Y��Fi"�!:���=��(F��v��;��c��0J�@[��g����:��c���	����R�p�r}�8_�e��t�2��Q�u?����uM���c<H�/�ZAJM��B��N��wA��*��s>�H@�.o3�����-�V����#��q��u'���[��U��#k�n����=�����������
Q��w�q8+��Y_-����38aV*�@�����u*8?�����<���Y��vQrb	��x��!������<,��?��e*(
K�j�����o����,�������D�TF�f.���!�!�d�X���OQ����@���$�}��:��m�{t�����^�i;�������.j@���	�$�|�nse
 ����V1�$4^R��I�X������@�`�:���
��b�8�mI����L������������b�,G?�c*@���8���Y?��:l��1�c�^�5�&�����He��RI�����G��m�8�����8����������)P�����1B���:�i)�:.8��)�1/M:�S�-�Hk-14�����G��)���3F�LN���x���+<
�����64#{�8�7{`�i|g��W����5����TV�'��t`���I��X���E�"	��Z�����(Y.�|*_}�KE�R�<:��D��Z�E<4LI�����o�t�������f�ub��B��/�i��j��$�*R�����r�F�J�2`71F�R�7�d��P	������Ba�<`��`��g��+M
�6�e��G��w��2�!}���d�����������?��v���$�;H�hK9u�i�����srH����P�`��j��-��@�/������K����cu��A���!i������@n@��4�te$�S�1(Ljo`w���n�fp������6����9��r����p�/��
���D��p��)t�P��E�z��������y)'���m�*3ca#F@�0D<���z��
J})l����/H�5b(���_O�
�`�u���^���������t#���
��
f��M�o^��
Q��AB��|3.��v����m���P�c5��M��F����Sh��y���.��'�X������*�����H�Z� �t�%��#YT�������.��>,S���������Q���^��|>��g���gQ��k�2�����seV4�/����P@���>�5�|�7���),	�'���y����cWd2��n��6�N�_Nq�5D�#�."���E8D��u~z�X}��[
���#��cU����e�3&g�K~��~���� d=����c5��A���(el��`.�?�D�4�q��U����3��n�F����]�O�Z���(t
�w��1F�}P���F��~�����*����k�k���f.�`�����>L�2���h�[��^��<�� �k���t��p�U�����
��=��a�?���Vb���M�c�+�� ��x�C�a��c�
�o�����jm���=w��������c�������7�M������a}��=�����=t�5�X7Jc�)V��7];����eL
W�_hIq0;�{FO������&�61��������.[d����J3k��D�������Ux���\���	r�-au>���%�d�&�)RV�`�X�3�v1(��gf(Mg�	W�_�u���R%
;��q�
[�4��B�i�Rg^�O"��cR�&��"Mg�.~�4��p 
��)u�0��/�����{F8�Lg���Z��C�n$E�e3��0D�~�J�G
�����������U>�������'��?+�� ����7���S$�C	�?N�����Y�]Ur����|�jW���o��2���VBd
:�����;HLE����^�R���x�;����\@ �?u�g5�T�
C;b:�3�3`����.5�A+wa������A:�]�����'�?U�u���#�+?k3���{X��1{j�^�t���z����+�u
�,�����'5��/����}��Iw��%BS����"j���)�0LD��+��$���j5�����������U;7��`CeM��Q������o����l
��2�5��E@?��d[�XN5�����Gm4/3�(�0VD(���i68���&3������J7�R64 ���2�8wh}��c���/�����m�?!�N������:��V}�����G�������An":�\�[�)_�|��1
z,�\*����^e��v�������b�0��i�K��]�0�+��tA�s�'�7�
[�K��)���'����
�8]��"X��c�).�F	G��n����w'IAu�E�m��L�P{���'�n]�E����	2�����m+�O���./�H�P�`���l9v��/vD��f_����k' �zt��eX���p^��acN7�[�+
.V����]����_���]��q���������������Gb~��{�������N��C�:����^��
��}�c���+U��o&��y����o�j������[�qx A���������#B^"YY�+'R��W;����������~]�%���!&�u��|I��*��3�H���W����<�J�]���?�[uK
q��NR��+�O�r�P��k�2X�1)��pmD�8��iD�������Wi���~R^]N$:+��������-��hZ�AH���&��6v
��`��-�&�C�g�.����/3�Bl�f�	�X{o\��'a�"����+���a?�*�9�&/���
�����j�=}���X�Dg:��t?+k0E�z��\i&���#%'�d�I��w"	��z^{�{~]���s�~�:Q���OxO���?}����o���8����97/���6��P��5x7�@6x�m���]�8��,�T4>�1��^X�����!������O�"��?3��@'�E�F�6%�U�����^�ot��1����Y
��vL��*B�N�NI�UgXd&�a.����scN+���tD�[���l(ri��)�'B'm����ma�����c[�8�[�u�01���-����uX�&k�����m���q����fH��
C1o���D��D������?��ldf��#�����z�%�����|~w����cl�v���O�8��\3�hkycv^l��9.c��fYB�3C����0Ui{��u���G��k>s=��\�OV�����J\�
��5D<�Y�������Y�����*���>�l�p�w����$����-�����[z:*�7��4�����vswOuh��{�7�����7��j�>)��:���[�a�~��+���oh>��E�BTQ�����N������JYI��#=)�>�o�g����.K��cZK���$Gf�J2��{)a���>��`�;�@����pP����Q(b��Ac�����9S���"������A���lQ��
���T�4�q��24������4Qm��i!�
`�tq��0I�n9!�������W(~W0XO���y��&y%@c��
'PEV��J����dSz�i�fbe���f�L
e���b^�D���i�QF�(K(����H�D&#�Q �!�r�^u
�e�@�l���X���%����qR���PV�B��Y�`%8�j���f	���Z�E,G0$��[�F�C��$M����^L���a���JL����4���^��d��/�s�%������%�a�.H��
�j
-�"
�p���%��r�^�>�����o�'MaC$��}���]@P�{	iA��K��
����iB��
6���2H��%L���J�m����h`�!��R�����s��P4�b5@�����@C���b[]�'~K�U�$�����wP��r�f�����<���e)}������
���P��������@1Y����r�> ��wp�����[MA��V�|M�>����N�#����Cd��_P+�e��`X8W�-�����'C<����P�x9}*Q�^�h`�
PK
�-^W]�r6��
benchdata/index_outputs.logPK
.^W���=c;
�benchdata/pgbench_logs_14_0001_sample_data_100k_1.log.11171PK
A^W��:B<c;
V
benchdata/pgbench_logs_14_0001_sample_data_100k_2.log.11175PK
Q^W+��;c;
�
benchdata/pgbench_logs_14_0001_sample_data_100k_3.log.11179PK
d^W�e�\<c;
benchdata/pgbench_logs_14_0001_sample_data_100k_4.log.11183PK
u^W���=a;
benchdata/pgbench_logs_14_0001_sample_data_100k_5.log.11187PK
�^Wwc�=c;
�benchdata/pgbench_logs_14_0001_sample_data_100k_6.log.11191PK
�^W����<b;
@benchdata/pgbench_logs_14_0001_sample_data_100k_7.log.11195PK
j^WPP^Af9
�benchdata/pgbench_logs_14_0001_sample_data_1m_1.log.11215PK
� ^W�?��Bf9
mbenchdata/pgbench_logs_14_0001_sample_data_1m_2.log.11219PK
�!^W�A��>f9
benchdata/pgbench_logs_14_0001_sample_data_1m_3.log.11223PK
W"^W����>e9
�benchdata/pgbench_logs_14_0001_sample_data_1m_4.log.11244PK
##^W3���@f9
0benchdata/pgbench_logs_14_0001_sample_data_1m_5.log.11248PK
�#^WS
s�>f9
�benchdata/pgbench_logs_14_0001_sample_data_1m_6.log.11252PK
�$^W����Bf9
\benchdata/pgbench_logs_14_0001_sample_data_1m_7.log.11273PK
�$^WdXQI<c;
�benchdata/pgbench_logs_14_0002_sample_data_100k_1.log.11295PK
�$^W$@�=c;
�	benchdata/pgbench_logs_14_0002_sample_data_100k_2.log.11299PK
�$^W��<b;
 
benchdata/pgbench_logs_14_0002_sample_data_100k_3.log.11303PK
�$^W���o<c;
�
benchdata/pgbench_logs_14_0002_sample_data_100k_4.log.11307PK

%^W��=c;
Jbenchdata/pgbench_logs_14_0002_sample_data_100k_5.log.11311PK
%^W�h?c;
�benchdata/pgbench_logs_14_0002_sample_data_100k_6.log.11315PK
+%^W�/��<c;
xbenchdata/pgbench_logs_14_0002_sample_data_100k_7.log.11319PK
�%^W�� >e9


benchdata/pgbench_logs_14_0002_sample_data_1m_1.log.11339PK
�&^WV�Af9
�
benchdata/pgbench_logs_14_0002_sample_data_1m_2.log.11343PK
p'^W�j^=f9
:benchdata/pgbench_logs_14_0002_sample_data_1m_3.log.11364PK
�(^W�5�?f9
�benchdata/pgbench_logs_14_0002_sample_data_1m_4.log.11368PK
p)^W0���>e9
dbenchdata/pgbench_logs_14_0002_sample_data_1m_5.log.11372PK
2*^W#�|>f9
�benchdata/pgbench_logs_14_0002_sample_data_1m_6.log.11393PK
�*^W��|>f9
�benchdata/pgbench_logs_14_0002_sample_data_1m_7.log.11397PK
�*^W���R<`;
#benchdata/pgbench_logs_14_0007_sample_data_100k_1.log.11419PK
+^W=��9_;
�benchdata/pgbench_logs_14_0007_sample_data_100k_2.log.11423PK

+^W���9:`;
Jbenchdata/pgbench_logs_14_0007_sample_data_100k_3.log.11427PK
+^Wm]�9`;
�benchdata/pgbench_logs_14_0007_sample_data_100k_4.log.11431PK
+^WPe�9`;
obenchdata/pgbench_logs_14_0007_sample_data_100k_5.log.11435PK
$+^WR�D�:`;

benchdata/pgbench_logs_14_0007_sample_data_100k_6.log.11439PK
,+^W�
*:`;
�benchdata/pgbench_logs_14_0007_sample_data_100k_7.log.11443PK
�+^W�Ea�?c9
'benchdata/pgbench_logs_14_0007_sample_data_1m_1.log.11463PK
�+^W�N�%=c9
�benchdata/pgbench_logs_14_0007_sample_data_1m_2.log.11484PK
V,^W#�V'>b9
Qbenchdata/pgbench_logs_14_0007_sample_data_1m_3.log.11488PK
�,^W���=c9
�benchdata/pgbench_logs_14_0007_sample_data_1m_4.log.11492PK
 -^Wn(��<b9
zbenchdata/pgbench_logs_14_0007_sample_data_1m_5.log.11496PK
�-^W���=c9

benchdata/pgbench_logs_14_0007_sample_data_1m_6.log.11500PK
�-^WRy��=c9
�benchdata/pgbench_logs_14_0007_sample_data_1m_7.log.11504PK
k^W/��>c=
5benchdata/pgbench_logs_14_master_sample_data_100k_1.log.10827PK
�^W
��=c=
�benchdata/pgbench_logs_14_master_sample_data_100k_2.log.11028PK
�^W�96�;c=
fbenchdata/pgbench_logs_14_master_sample_data_100k_3.log.11032PK
�^W���k=c=
�benchdata/pgbench_logs_14_master_sample_data_100k_4.log.11036PK
�^W4��~<c=
�benchdata/pgbench_logs_14_master_sample_data_100k_5.log.11040PK
�^W!���=c=
+benchdata/pgbench_logs_14_master_sample_data_100k_6.log.11044PK
�^W����=c=
�benchdata/pgbench_logs_14_master_sample_data_100k_7.log.11048PK
W^W��"�@f;
[benchdata/pgbench_logs_14_master_sample_data_1m_1.log.11068PK
K^W�5@f;
�benchdata/pgbench_logs_14_master_sample_data_1m_2.log.11072PK
;^W�lBf;
�benchdata/pgbench_logs_14_master_sample_data_1m_3.log.11096PK
0^W!.RM?f;
(benchdata/pgbench_logs_14_master_sample_data_1m_4.log.11100PK
,^W���OAf;
�benchdata/pgbench_logs_14_master_sample_data_1m_5.log.11104PK
"^Wmo`j?f;
Z benchdata/pgbench_logs_14_master_sample_data_1m_6.log.11126PK
^W��nM@f;
� benchdata/pgbench_logs_14_master_sample_data_1m_7.log.11132PK
.^W�c���+6
�!benchdata/pgbench_stats_14_0001_sample_data_100k_1.outPK
A^W��[��+6
�%benchdata/pgbench_stats_14_0001_sample_data_100k_2.outPK
Q^W����+6
�)benchdata/pgbench_stats_14_0001_sample_data_100k_3.outPK
d^W��G�+6
).benchdata/pgbench_stats_14_0001_sample_data_100k_4.outPK
u^W�?2��+6
Y2benchdata/pgbench_stats_14_0001_sample_data_100k_5.outPK
�^W�����+6
�6benchdata/pgbench_stats_14_0001_sample_data_100k_6.outPK
�^W��'��+6
�:benchdata/pgbench_stats_14_0001_sample_data_100k_7.outPK
j^WY����,4
�>benchdata/pgbench_stats_14_0001_sample_data_1m_1.outPK
� ^W�����,4
:Cbenchdata/pgbench_stats_14_0001_sample_data_1m_2.outPK
�!^W�*
,4
�Gbenchdata/pgbench_stats_14_0001_sample_data_1m_3.outPK
W"^WTL��,4
�Kbenchdata/pgbench_stats_14_0001_sample_data_1m_4.outPK
##^Wiy��,4
Pbenchdata/pgbench_stats_14_0001_sample_data_1m_5.outPK
�#^W�0�D�,4
\Tbenchdata/pgbench_stats_14_0001_sample_data_1m_6.outPK
�$^WP���,4
�Xbenchdata/pgbench_stats_14_0001_sample_data_1m_7.outPK
�$^W�:���+6
�\benchdata/pgbench_stats_14_0002_sample_data_100k_1.outPK
�$^W��v��+6
abenchdata/pgbench_stats_14_0002_sample_data_100k_2.outPK
�$^W�����+6
Debenchdata/pgbench_stats_14_0002_sample_data_100k_3.outPK
�$^Wq���+6
qibenchdata/pgbench_stats_14_0002_sample_data_100k_4.outPK

%^W���g�+6
�mbenchdata/pgbench_stats_14_0002_sample_data_100k_5.outPK
%^W�g��+6
�qbenchdata/pgbench_stats_14_0002_sample_data_100k_6.outPK
+%^W��6��+6
�ubenchdata/pgbench_stats_14_0002_sample_data_100k_7.outPK
�%^W18d5�,4
zbenchdata/pgbench_stats_14_0002_sample_data_1m_1.outPK
�&^W��Qs�,4
g~benchdata/pgbench_stats_14_0002_sample_data_1m_2.outPK
p'^W�NQu�,4
��benchdata/pgbench_stats_14_0002_sample_data_1m_3.outPK
�(^W0|�\�,4
��benchdata/pgbench_stats_14_0002_sample_data_1m_4.outPK
p)^W��
�,4
0�benchdata/pgbench_stats_14_0002_sample_data_1m_5.outPK
2*^W���?�,4
q�benchdata/pgbench_stats_14_0002_sample_data_1m_6.outPK
�*^W]����,4
��benchdata/pgbench_stats_14_0002_sample_data_1m_7.outPK
�*^W��[�*6
��benchdata/pgbench_stats_14_0007_sample_data_100k_1.outPK
+^W'��L�*6
+�benchdata/pgbench_stats_14_0007_sample_data_100k_2.outPK

+^W�h��*6
U�benchdata/pgbench_stats_14_0007_sample_data_100k_3.outPK
+^Wq*���*6
��benchdata/pgbench_stats_14_0007_sample_data_100k_4.outPK
+^W�����*6
��benchdata/pgbench_stats_14_0007_sample_data_100k_5.outPK
$+^W8���*6
��benchdata/pgbench_stats_14_0007_sample_data_100k_6.outPK
,+^W�"�x�*6
�benchdata/pgbench_stats_14_0007_sample_data_100k_7.outPK
�+^W+���+4
?�benchdata/pgbench_stats_14_0007_sample_data_1m_1.outPK
�+^W(����+4
��benchdata/pgbench_stats_14_0007_sample_data_1m_2.outPK
V,^WO���+4
��benchdata/pgbench_stats_14_0007_sample_data_1m_3.outPK
�,^W(��+4
�benchdata/pgbench_stats_14_0007_sample_data_1m_4.outPK
 -^W�_GR�+4
^�benchdata/pgbench_stats_14_0007_sample_data_1m_5.outPK
�-^W�!���+4
��benchdata/pgbench_stats_14_0007_sample_data_1m_6.outPK
�-^W%����+4
��benchdata/pgbench_stats_14_0007_sample_data_1m_7.outPK
k^W��
F�+8
)�benchdata/pgbench_stats_14_master_sample_data_100k_1.outPK
�^WG����+8
K�benchdata/pgbench_stats_14_master_sample_data_100k_2.outPK
�^W�Vf��+8
v�benchdata/pgbench_stats_14_master_sample_data_100k_3.outPK
�^W�(���+8
��benchdata/pgbench_stats_14_master_sample_data_100k_4.outPK
�^W�`oZ�+8
��benchdata/pgbench_stats_14_master_sample_data_100k_5.outPK
�^W�<9H�+8
�benchdata/pgbench_stats_14_master_sample_data_100k_6.outPK
�^WQU��+8
?�benchdata/pgbench_stats_14_master_sample_data_100k_7.outPK
W^W��\�,6
j�benchdata/pgbench_stats_14_master_sample_data_1m_1.outPK
K^W&����,6
��benchdata/pgbench_stats_14_master_sample_data_1m_2.outPK
;^W"�CH�,6
��benchdata/pgbench_stats_14_master_sample_data_1m_3.outPK
0^W�|1�,6
L�benchdata/pgbench_stats_14_master_sample_data_1m_4.outPK
,^W�:���,6
�

benchdata/pgbench_stats_14_master_sample_data_1m_5.outPK
"^W����,6
�
benchdata/pgbench_stats_14_master_sample_data_1m_6.outPK
^W�0���,6
!

benchdata/pgbench_stats_14_master_sample_data_1m_7.outPK
0^W,��z
j
bench_indexes.shPK
��AW<+�>zu
2
bench_indexes.sqlPK
@�^W�����O
�z
 �
Perf_results_v14.odsPKtt�-�d

From f039eeac059a0b21d7a1fa0c6fba8ddc1b580943 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 20:04:56 +0100
Subject: [PATCH v14 5/7] btree: Optimize nbts_attiter for indexes with a
 single key attribute

This removes the index_getattr_nocache call path, which can have significant
overhead, and uses constant 0 offset; removing memory access dependencies.
---
 src/backend/access/nbtree/README        |  1 +
 src/backend/access/nbtree/nbtree_spec.c |  3 ++
 src/include/access/nbtree.h             | 35 ++++++++++++++++
 src/include/access/nbtree_spec.h        | 56 ++++++++++++++++++++++++-
 4 files changed, 93 insertions(+), 2 deletions(-)

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 516b2c25ed..5cd408e2b4 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1118,6 +1118,7 @@ in the index AM to call the specialized functions, increasing the
 performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
+ - indexes with only a single key attribute
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 6b766581ab..21635397ed 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_SINGLE_KEYATT:
+			_bt_specialize_single_keyatt(rel);
+			break;
 		case NBTS_CTX_DEFAULT:
 			break;
 	}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 2da051c680..1b88dca08f 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1127,6 +1127,7 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
 typedef enum NBTS_CTX {
+	NBTS_CTX_SINGLE_KEYATT, 
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
@@ -1136,9 +1137,43 @@ static inline NBTS_CTX _nbt_spec_context(Relation irel)
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
+	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+		return NBTS_CTX_SINGLE_KEYATT;
+
 	return NBTS_CTX_CACHED;
 }
 
+static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
+									bool *isNull)
+{
+	Datum	result;
+	if (IndexTupleHasNulls(tuple))
+	{
+		if (att_isnull(0, (bits8 *)(tuple) + sizeof(IndexTupleData)))
+		{
+			*isNull = true;
+			result = (Datum) 0;
+		}
+		else
+		{
+			*isNull = false;
+			result = fetchatt(TupleDescAttr(tupleDesc, 0),
+							  ((char *) tuple)
+							  + MAXALIGN(sizeof(IndexTupleData)
+							  + sizeof(IndexAttributeBitMapData)));
+		}
+	}
+	else
+	{
+		*isNull = false;
+		result = fetchatt(TupleDescAttr(tupleDesc, 0),
+						  ((char *) tuple)
+						  + MAXALIGN(sizeof(IndexTupleData)));
+	}
+
+	return result;
+}
+
 
 #define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
 #include "nbtree_spec.h"
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index fa38b09c6e..8e476c300d 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -44,6 +44,7 @@
 /*
  * Macros used in the nbtree specialization code.
  */
+#define NBTS_TYPE_SINGLE_KEYATT single_keyatt
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -51,8 +52,10 @@
 /* contextual specializations */
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
-	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
+		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		) \
 	) \
 )
 
@@ -164,6 +167,55 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 3: SINGLE_KEYATT
+ *
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path cannot be used for indexes with multiple key
++ *  columns, because it never considers the next column.
+ */
+
+/* the default context (and later contexts) do need to specialize, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel)
+
+#define NBTS_SPECIALIZING_SINGLE_KEYATT
+#define NBTS_TYPE NBTS_TYPE_SINGLE_KEYATT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	_bt_getfirstatt(itup, tupDesc, &NBTS_MAKE_NAME(itup, isNull)) \
+)
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_SINGLE_KEYATT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All next uses of nbts_prep_ctx are in non-templated code, so here we make
  * sure we actually create the context.
-- 
2.40.1

From 33d1c09d41faa35e6a10a1fe55cd09d069b85e53 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Sun, 29 Oct 2023 21:39:23 +0100
Subject: [PATCH v14 2/7] btree: optimize _bt_moveright using downlink's right
 separator

Due to the inner workings of the btree, it is extremely likely that the
right separator of the btree page's downlink on the parent page matches
the downlinked page's HIKEY: Only when the page was split after we
accessed its parent page (and this split wasn't completed yet) the HIKEY
will not match.

So, instead of doing _bt_compare in _bt_moveright, we can store the
right separator key of the downlink, and check if it matches the HIKEY of
the linked page. If they match, we don't have to call the relatively
expensive _bt_compare, which allows us to reuse the _bt_compare result of
the right separator key.

This reduces the average number of all-attribute _bt_compare operations
we need to do on a page from 3 to 2, thus further increasing performance
of indexes that have expensive compare operations.
---
 src/backend/access/nbtree/README      | 25 +++++++-
 src/backend/access/nbtree/nbtsearch.c | 83 +++++++++++++++++++++++----
 2 files changed, 96 insertions(+), 12 deletions(-)

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 61601aca61..0aeee328f1 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -933,7 +933,30 @@ that has no "wasteful" prefix that we can skip.
 With the above optimizations, dynamic prefix truncation improves the worst
 case complexity of indexing from O(tree_height * natts * log(tups_per_page))
 to O(tree_height * (3*natts + log(tups_per_page))) attribute compare
-operations, which can improve performance significantly.
+operations, which can improve performance significantly.  If we also take
+the downlink right separator/HIKEY moveright optimization into account, that
+is further reduced to O(tree_height * (2*natts + log(tups_per_page)))
+attribute compares, which further improves performance.
+
+Notes about the right separator/HIKEY moveright optimization
+------------------------------------------------------------
+
+Page splits consistently cause the HIKEY of the split page to be inserted
+into the parent page as the right separator of the page's downlink (or,
+as the split page's new right sibling's left link), with the only
+difference between the HIKEY and the separator being the contents of the
+IndexTupleData struct of these tuples: the payloads are bit-identical.
+This allows us to reuse the _bt_compare result of the right separator key
+for the downlinked page's HIKEY, if we can determine that those are indeed
+bit-identical: Concurrent page splits and deletions may have caused the
+downlinked page to get a different HIKEY, which could have a different
+_bt_compare result.  To make this work, in _bt_search we cache the
+current downlink's right separator key, to then in the _bt_moveright
+phase of the layer below use memcmp() to validate our assumptions about
+the HIKEY matching the downlink's right separator key.  Only if the
+assumption is proven wrong (memcmp(HIKEY, parent_rsep) != 0), we call
+_bt_compare(), otherwise we can be certain that the parent page's result
+is unchanged, i.e. that _bt_compare would return "<".
 
 Notes about deduplication
 -------------------------
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index 71fd658d15..6dac8169a5 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -26,10 +26,12 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *rsepcmpcol);
 static Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
 							Buffer buf, bool forupdate, BTStack stack,
-							int access, AttrNumber *prefix);
+							int access, AttrNumber *prefix,
+							IndexTuple rightsep);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
 static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
@@ -101,6 +103,12 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	union {
+		char	data[MAXALIGN_DOWN(BLCKSZ / 3)];
+		IndexTupleData tuple;
+		double	_align;
+	}			rsepbuf;
+	IndexTuple	rightsep = NULL;
 	AttrNumber	highkeyprefix = 1;
 
 	/* heaprel must be set whenever _bt_allocbuf is reachable */
@@ -138,7 +146,7 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * opportunity to finish splits of internal pages too.
 		 */
 		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access, &highkeyprefix);
+							  stack_in, page_access, &highkeyprefix, rightsep);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -150,12 +158,31 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * Find the appropriate pivot tuple on this page.  Its downlink points
 		 * to the child page that we're about to descend to.
 		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeyprefix);
 		itemid = PageGetItemId(page, offnum);
 		itup = (IndexTuple) PageGetItem(page, itemid);
 		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
 		child = BTreeTupleGetDownLink(itup);
 
+		if (offnum < PageGetMaxOffsetNumber(page))
+		{
+			ItemId	rightsepitem = PageGetItemId(page, offnum + 1);
+			IndexTuple pagerightsep = (IndexTuple) PageGetItem(page, rightsepitem);
+			memcpy(rsepbuf.data, pagerightsep, ItemIdGetLength(rightsepitem));
+			rightsep = &rsepbuf.tuple;
+		}
+		else if (!P_RIGHTMOST(opaque))
+		{
+			/*
+			 * The rightmost data tuple on inner page has P_HIKEY as its right
+			 * separator.
+			 */
+			ItemId	rightsepitem = PageGetItemId(page, P_HIKEY);
+			IndexTuple pagerightsep = (IndexTuple) PageGetItem(page, rightsepitem);
+			memcpy(rsepbuf.data, pagerightsep, ItemIdGetLength(rightsepitem));
+			rightsep = &rsepbuf.tuple;
+		}
+
 		/*
 		 * We need to save the location of the pivot tuple we chose in a new
 		 * stack entry for this page/level.  If caller ends up splitting a
@@ -201,7 +228,7 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * move right to its new sibling.  Do that.
 		 */
 		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
-							  &highkeyprefix);
+							  &highkeyprefix, rightsep);
 	}
 
 	return stack_in;
@@ -248,7 +275,8 @@ _bt_moveright(Relation rel,
 			  bool forupdate,
 			  BTStack stack,
 			  int access,
-			  AttrNumber *prefix)
+			  AttrNumber *prefix,
+			  IndexTuple rightsep)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -327,8 +355,30 @@ _bt_moveright(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) ||
-			_bt_compare(rel, key, page, P_HIKEY, &prefixatt) >= cmpval)
+		if (P_IGNORE(opaque))
+		{
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+
+		if (PointerIsValid(rightsep))
+		{
+			ItemId	hikeyid = PageGetItemId(page, P_HIKEY);
+			IndexTuple highkey = (IndexTuple) PageGetItem(page, hikeyid);
+
+			if (ItemIdGetLength(hikeyid) == IndexTupleSize(rightsep) &&
+				memcmp(&highkey[1], &rightsep[1],
+					   IndexTupleSize(rightsep) - sizeof(IndexTupleData)) == 0)
+			{
+				/*
+				 * *comparecol contains the _bt_compare(... &comparecol)
+				 * result for rightsep, no need to update it
+				 */
+				break;
+			}
+		}
+
+		if (_bt_compare(rel, key, page, P_HIKEY, &prefixatt) >= cmpval)
 		{
 			/* set the compare column when breaking out of the loop */
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
@@ -372,7 +422,8 @@ _bt_moveright(Relation rel,
 static OffsetNumber
 _bt_binsrch(Relation rel,
 			BTScanInsert key,
-			Buffer buf)
+			Buffer buf,
+			AttrNumber *rsepcmpcol)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -385,7 +436,7 @@ _bt_binsrch(Relation rel,
 	 * "highkeyprefix" is the value for this page's high key (if any) or 1
 	 * (no established shared prefix)
 	 */
-	AttrNumber	highkeyprefix = 1,
+	AttrNumber	highkeyprefix = *rsepcmpcol,
 				lowkeyprefix = 1;
 
 	page = BufferGetPage(buf);
@@ -407,7 +458,11 @@ _bt_binsrch(Relation rel,
 	 * never empty (an internal page must have children).
 	 */
 	if (unlikely(high < low))
+	{
+		/* Prefixes don't make much sense in empty pages, so just reset it */
+		*rsepcmpcol = 1;
 		return low;
+	}
 
 	/*
 	 * Binary search to find the first key on the page >= scan key, or first
@@ -450,6 +505,8 @@ _bt_binsrch(Relation rel,
 		}
 	}
 
+	*rsepcmpcol = highkeyprefix;
+
 	/*
 	 * At this point we have high == low, but be careful: they could point
 	 * past the last slot on the page.
@@ -1482,7 +1539,11 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	_bt_initialize_more_data(so, dir);
 
 	/* position to the precise item on the page */
-	offnum = _bt_binsrch(rel, &inskey, buf);
+	{
+		/* bt_search doesn't  */
+		AttrNumber prefix = 1;
+		offnum = _bt_binsrch(rel, &inskey, buf, &prefix);
+	}
 
 	/*
 	 * If nextkey = false, we are positioned at the first item >= scan key, or
-- 
2.40.1

From 22f7c69552bcd6b89a586554a1361926925f4332 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Sun, 29 Oct 2023 21:39:23 +0100
Subject: [PATCH v14 1/7] btree: Implement dynamic prefix compression

Because tuples in the btree are ordered, if some prefix of the
scan attributes on both sides of the compared tuple are equal
to the scankey, then the current tuple that is being compared
must also contain the same prefix that equals the scankey.

Due to concurrent page splits and deletes, the key range of a
page may move while we travel down the btree. This means we can't
directly reuse left- and right-key prefixes we established on the
parent page while we descend the btree: the data on the page
may not match the parent page's separator keys anymore (see [0]).

So, we can't always descend the btree while keeping the discovered
prefixes. However, on each page we only see a snapshot of the
page, so we can use dynamic prefix truncation at the page level.
This still improves the worst-case number of compare operations
during btree descent from depth * ceil(log(tuples_per_page)) * natts
to depth * (ceil(log(tuples_per_page)) + 3 * natts).

In passing, move _bt_moveright from btree.h to nbtsearch.c: there
was no usage of the function left outside nbtsearch.c.
---
 contrib/amcheck/verify_nbtree.c       |  25 +++++--
 src/backend/access/nbtree/README      |  34 +++++++++
 src/backend/access/nbtree/nbtinsert.c |  34 ++++++---
 src/backend/access/nbtree/nbtsearch.c | 101 +++++++++++++++++++++++---
 src/include/access/nbtree.h           |   9 +--
 5 files changed, 168 insertions(+), 35 deletions(-)

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 7282cf7fc8..40fc0a8af7 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -1706,6 +1706,8 @@ bt_target_page_check(BtreeCheckState *state)
 		if (state->checkunique && state->indexinfo->ii_Unique &&
 			P_ISLEAF(topaque) && OffsetNumberNext(offset) <= max)
 		{
+			AttrNumber cmpattr = 1;
+
 			/* Save current scankey tid */
 			scantid = skey->scantid;
 
@@ -1722,7 +1724,7 @@ bt_target_page_check(BtreeCheckState *state)
 			 * treated as different to any other key.
 			 */
 			if (_bt_compare(state->rel, skey, state->target,
-							OffsetNumberNext(offset)) != 0 || skey->anynullkeys)
+							OffsetNumberNext(offset), &cmpattr) != 0 || skey->anynullkeys)
 			{
 				lVis_i = -1;
 				lVis_tid = NULL;
@@ -1801,6 +1803,8 @@ bt_target_page_check(BtreeCheckState *state)
 			if (state->checkunique && state->indexinfo->ii_Unique &&
 				rightkey && P_ISLEAF(topaque) && rightblock_number != P_NONE)
 			{
+				AttrNumber cmpattr = 1;
+
 				elog(DEBUG2, "check cross page unique condition");
 
 				/*
@@ -1811,7 +1815,7 @@ bt_target_page_check(BtreeCheckState *state)
 				rightkey->scantid = NULL;
 
 				/* The first key on the next page is the same */
-				if (_bt_compare(state->rel, rightkey, state->target, max) == 0 && !rightkey->anynullkeys)
+				if (_bt_compare(state->rel, rightkey, state->target, max, &cmpattr) == 0 && !rightkey->anynullkeys)
 				{
 					elog(DEBUG2, "cross page equal keys");
 					state->target = palloc_btree_page(state,
@@ -3012,6 +3016,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		BTInsertStateData insertstate;
 		OffsetNumber offnum;
 		Page		page;
+		AttrNumber	compareattr = 1;
 
 		insertstate.itup = itup;
 		insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
@@ -3021,13 +3026,13 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 		insertstate.buf = lbuf;
 
 		/* Get matching tuple on leaf page */
-		offnum = _bt_binsrch_insert(state->rel, &insertstate);
+		offnum = _bt_binsrch_insert(state->rel, &insertstate, 1);
 		/* Compare first >= matching item on leaf page, if any */
 		page = BufferGetPage(lbuf);
 		/* Should match on first heap TID when tuple has a posting list */
 		if (offnum <= PageGetMaxOffsetNumber(page) &&
 			insertstate.postingoff <= 0 &&
-			_bt_compare(state->rel, key, page, offnum) == 0)
+			_bt_compare(state->rel, key, page, offnum, &compareattr) == 0)
 			exists = true;
 		_bt_relbuf(state->rel, lbuf);
 	}
@@ -3089,6 +3094,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	compareattr = 1;
 
 	Assert(key->pivotsearch);
 
@@ -3099,7 +3105,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	if (!key->heapkeyspace)
 		return invariant_leq_offset(state, key, upperbound);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &compareattr);
 
 	/*
 	 * _bt_compare() is capable of determining that a scankey with a
@@ -3151,10 +3157,11 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	AttrNumber	compareattr = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, upperbound);
+	cmp = _bt_compare(state->rel, key, state->target, upperbound, &compareattr);
 
 	return cmp <= 0;
 }
@@ -3174,10 +3181,11 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	AttrNumber	compareattr = 1;
 
 	Assert(key->pivotsearch);
 
-	cmp = _bt_compare(state->rel, key, state->target, lowerbound);
+	cmp = _bt_compare(state->rel, key, state->target, lowerbound, &compareattr);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
@@ -3212,13 +3220,14 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	AttrNumber	compareattr = 1;
 
 	Assert(key->pivotsearch);
 
 	/* Verify line pointer before checking tuple */
 	itemid = PageGetItemIdCareful(state, nontargetblock, nontarget,
 								  upperbound);
-	cmp = _bt_compare(state->rel, key, nontarget, upperbound);
+	cmp = _bt_compare(state->rel, key, nontarget, upperbound, &compareattr);
 
 	/* pg_upgrade'd indexes may legally have equal sibling tuples */
 	if (!key->heapkeyspace)
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 52e646c7f7..61601aca61 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -901,6 +901,40 @@ large groups of duplicates, maximizing space utilization.  Note also that
 deduplication more efficient.  Deduplication can be performed infrequently,
 without merging together existing posting list tuples too often.
 
+Notes about dynamic prefix truncation
+-------------------------------------
+
+When we do a binary search on a sorted set (such as a BTree), we know that a
+tuple will be smaller than its left neighbour, and larger than its right
+neighbour.  If we know that both the left and right neighbour share a prefix
+with the scan key, we deduce that the current tuple must also share this
+prefix with the scan key, which allows us to skip this shared prefix during
+tuple compare operations when we descend the btree.
+
+However, the BTree is not a static sorted list: It is a dynamic data
+structure which changes over time.  Because of this, we cannot just reuse the
+established prefix from the parent page: concurrent page deletions may have
+moved in new tuples from the keyspace left of the left separator of this
+page's downlink on the parent page, and page splits may have moved tuples
+that were previously in this page's indicated keyspace away from the page.
+This means that we have to re-establish the prefix that is shared with the
+scan key at every level of the btree.
+
+Note that this is most effective on indexes where a prefix of key columns has
+many duplicate values.  Compare operations on full index tuples stop at the
+first non-equal attribute: it is quite unlikely that an index on
+(unique, 1, 1, 1) will ever compare the latter columns, while one on
+(1, 1, 1, unique) will essentially always have to compare all attributes to
+hit an attribute that isn't equal to that of the scan key.  The dynamic
+prefix truncation allows PostgreSQL to skip most compare operations on the
+(1, 1, 1 ...) prefix, but it cannot improve the (unique, ...) case because
+that has no "wasteful" prefix that we can skip.
+
+With the above optimizations, dynamic prefix truncation improves the worst
+case complexity of indexing from O(tree_height * natts * log(tups_per_page))
+to O(tree_height * (3*natts + log(tups_per_page))) attribute compare
+operations, which can improve performance significantly.
+
 Notes about deduplication
 -------------------------
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 9cff4f2931..b9f2580c1d 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -328,6 +328,7 @@ _bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
 		{
 			Page		page;
 			BTPageOpaque opaque;
+			AttrNumber	prefix = 1;
 
 			_bt_checkpage(rel, insertstate->buf);
 			page = BufferGetPage(insertstate->buf);
@@ -346,7 +347,8 @@ _bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
 				!P_IGNORE(opaque) &&
 				PageGetFreeSpace(page) > insertstate->itemsz &&
 				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&prefix) > 0)
 			{
 				/*
 				 * Caller can use the fastpath optimization because cached
@@ -440,7 +442,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	 * in the fastpath below, but also in the _bt_findinsertloc() call later.
 	 */
 	Assert(!insertstate->bounds_valid);
-	offset = _bt_binsrch_insert(rel, insertstate);
+	offset = _bt_binsrch_insert(rel, insertstate, 1);
 
 	/*
 	 * Scan over all equal tuples, looking for live conflicts.
@@ -450,6 +452,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	Assert(itup_key->scantid == NULL);
 	for (;;)
 	{
+		AttrNumber	cmpatt = 1;
+
 		/*
 		 * Each iteration of the loop processes one heap TID, not one index
 		 * tuple.  Current offset number for page isn't usually advanced on
@@ -485,7 +489,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				Assert(insertstate->bounds_valid);
 				Assert(insertstate->low >= P_FIRSTDATAKEY(opaque));
 				Assert(insertstate->low <= insertstate->stricthigh);
-				Assert(_bt_compare(rel, itup_key, page, offset) < 0);
+				Assert(_bt_compare(rel, itup_key, page, offset, &cmpatt) < 0);
 				break;
 			}
 
@@ -510,7 +514,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 				if (!inposting)
 				{
 					/* Plain tuple, or first TID in posting list tuple */
-					if (_bt_compare(rel, itup_key, page, offset) != 0)
+					if (_bt_compare(rel, itup_key, page, offset, &cmpatt) != 0)
 						break;	/* we're past all the equal tuples */
 
 					/* Advanced curitup */
@@ -720,11 +724,12 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 		else
 		{
 			int			highkeycmp;
+			cmpatt = 1;
 
 			/* If scankey == hikey we gotta check the next page too */
 			if (P_RIGHTMOST(opaque))
 				break;
-			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY);
+			highkeycmp = _bt_compare(rel, itup_key, page, P_HIKEY, &cmpatt);
 			Assert(highkeycmp <= 0);
 			if (highkeycmp != 0)
 				break;
@@ -867,6 +872,8 @@ _bt_findinsertloc(Relation rel,
 
 			for (;;)
 			{
+				AttrNumber	cmpatt = 1;
+
 				/*
 				 * Does the new tuple belong on this page?
 				 *
@@ -884,7 +891,7 @@ _bt_findinsertloc(Relation rel,
 
 				/* Test '<=', not '!=', since scantid is set now */
 				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpatt) <= 0)
 					break;
 
 				_bt_stepright(rel, heapRel, insertstate, stack);
@@ -937,6 +944,8 @@ _bt_findinsertloc(Relation rel,
 		 */
 		while (PageGetFreeSpace(page) < insertstate->itemsz)
 		{
+			AttrNumber	cmpatt = 1;
+
 			/*
 			 * Before considering moving right, see if we can obtain enough
 			 * space by erasing LP_DEAD items
@@ -967,7 +976,7 @@ _bt_findinsertloc(Relation rel,
 				break;
 
 			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpatt) != 0 ||
 				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
 				break;
 
@@ -982,10 +991,13 @@ _bt_findinsertloc(Relation rel,
 	 * We should now be on the correct page.  Find the offset within the page
 	 * for the new tuple. (Possibly reusing earlier search bounds.)
 	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
+	{
+		AttrNumber	cmpatt PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpatt) <= 0);
+	}
 
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 
 	if (insertstate->postingoff == -1)
 	{
@@ -1004,7 +1016,7 @@ _bt_findinsertloc(Relation rel,
 		 */
 		Assert(!insertstate->bounds_valid);
 		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
 		Assert(insertstate->postingoff == 0);
 	}
 
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index efc5284e5b..71fd658d15 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -27,6 +27,9 @@
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
 static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
+							Buffer buf, bool forupdate, BTStack stack,
+							int access, AttrNumber *prefix);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
 static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
@@ -98,6 +101,7 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 {
 	BTStack		stack_in = NULL;
 	int			page_access = BT_READ;
+	AttrNumber	highkeyprefix = 1;
 
 	/* heaprel must be set whenever _bt_allocbuf is reachable */
 	Assert(access == BT_READ || access == BT_WRITE);
@@ -134,7 +138,7 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * opportunity to finish splits of internal pages too.
 		 */
 		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access);
+							  stack_in, page_access, &highkeyprefix);
 
 		/* if this is a leaf page, we're done */
 		page = BufferGetPage(*bufP);
@@ -185,6 +189,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 	 */
 	if (access == BT_WRITE && page_access == BT_READ)
 	{
+		highkeyprefix = 1;
+
 		/* trade in our read lock for a write lock */
 		_bt_unlockbuf(rel, *bufP);
 		_bt_lockbuf(rel, *bufP, BT_WRITE);
@@ -194,7 +200,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
 		 * but before we acquired a write lock.  If it has, we may need to
 		 * move right to its new sibling.  Do that.
 		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE);
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
+							  &highkeyprefix);
 	}
 
 	return stack_in;
@@ -230,6 +237,8 @@ _bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
  * On entry, we have the buffer pinned and a lock of the type specified by
  * 'access'.  If we move right, we release the buffer and lock and acquire
  * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * On exit, we've updated *comparecol with the prefix that the high key shares
  */
 Buffer
 _bt_moveright(Relation rel,
@@ -238,7 +247,8 @@ _bt_moveright(Relation rel,
 			  Buffer buf,
 			  bool forupdate,
 			  BTStack stack,
-			  int access)
+			  int access,
+			  AttrNumber *prefix)
 {
 	Page		page;
 	BTPageOpaque opaque;
@@ -262,16 +272,36 @@ _bt_moveright(Relation rel,
 	 *
 	 * We also have to move right if we followed a link that brought us to a
 	 * dead page.
+	 *
+	 * Note: It is important that *comparecol is set to an accurate value at
+	 * return. Rightmost pages have no prefix, thus set it to 1.  In all other
+	 * cases, it must be updated with the prefix result of this page's
+	 * HIGHKEY's full _bt_compare.
 	 */
 	cmpval = key->nextkey ? 0 : 1;
 
 	for (;;)
 	{
+		/*
+		 * We explicitly don't reuse the prefix argument of this function,
+		 * as we may need to move multiple times, and we don't want to
+		 * overwrite the value stored in *prefix if we could reuse it.
+		 * Additionally, its value will be useless for any of our own
+		 * _bt_compare calls: only if the downlink right separator/HIKEY
+		 * optimization is applicable we can use the value, and when it is
+		 * applicable then we don't have to call _bt_compare.
+		 */
+		AttrNumber	prefixatt = 1;
+
 		page = BufferGetPage(buf);
 		opaque = BTPageGetOpaque(page);
 
 		if (P_RIGHTMOST(opaque))
+		{
+			/* set the compare column when breaking out of the loop */
+			*prefix = 1;
 			break;
+		}
 
 		/*
 		 * Finish any incomplete splits we encounter along the way.
@@ -297,14 +327,19 @@ _bt_moveright(Relation rel,
 			continue;
 		}
 
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
+		if (P_IGNORE(opaque) ||
+			_bt_compare(rel, key, page, P_HIKEY, &prefixatt) >= cmpval)
 		{
-			/* step right one page */
+			/* set the compare column when breaking out of the loop */
 			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
 			continue;
 		}
 		else
+		{
+			/* make sure to set the compare column */
+			*prefix = prefixatt;
 			break;
+		}
 	}
 
 	if (P_IGNORE(opaque))
@@ -345,6 +380,13 @@ _bt_binsrch(Relation rel,
 				high;
 	int32		result,
 				cmpval;
+	/*
+	 * Prefix bounds, for the high/low offset's compare columns.
+	 * "highkeyprefix" is the value for this page's high key (if any) or 1
+	 * (no established shared prefix)
+	 */
+	AttrNumber	highkeyprefix = 1,
+				lowkeyprefix = 1;
 
 	page = BufferGetPage(buf);
 	opaque = BTPageGetOpaque(page);
@@ -377,6 +419,10 @@ _bt_binsrch(Relation rel,
 	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
 	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
 	 *
+	 * We maintain highkeyprefix and lowkeyprefix to keep track of prefixes
+	 * that tuples share with the scan key, potentially allowing us to skip a
+	 * prefix in the midpoint comparison.
+	 *
 	 * We can fall out when high == low.
 	 */
 	high++;						/* establish the loop invariant for high */
@@ -386,15 +432,22 @@ _bt_binsrch(Relation rel,
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	prefix = Min(highkeyprefix, lowkeyprefix); /* update prefix bounds */
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &prefix);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowkeyprefix = prefix;
+		}
 		else
+		{
 			high = mid;
+			highkeyprefix = prefix;
+		}
 	}
 
 	/*
@@ -439,7 +492,8 @@ _bt_binsrch(Relation rel,
  * list split).
  */
 OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highkeyprefix)
 {
 	BTScanInsert key = insertstate->itup_key;
 	Page		page;
@@ -449,6 +503,7 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 				stricthigh;
 	int32		result,
 				cmpval;
+	AttrNumber	lowkeyprefix = 1;
 
 	page = BufferGetPage(insertstate->buf);
 	opaque = BTPageGetOpaque(page);
@@ -499,16 +554,22 @@ _bt_binsrch_insert(Relation rel, BTInsertState insertstate)
 	while (high > low)
 	{
 		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	prefix = Min(highkeyprefix, lowkeyprefix);
 
 		/* We have low <= mid < high, so mid points at a real slot */
 
-		result = _bt_compare(rel, key, page, mid);
+		result = _bt_compare(rel, key, page, mid, &prefix);
 
 		if (result >= cmpval)
+		{
 			low = mid + 1;
+			lowkeyprefix = prefix;
+		}
 		else
 		{
 			high = mid;
+			highkeyprefix = prefix;
+
 			if (result != 0)
 				stricthigh = high;
 		}
@@ -643,6 +704,13 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
  * matching TID in the posting tuple, which caller must handle
  * themselves (e.g., by splitting the posting list tuple).
  *
+ * NOTE: The "comparecol" argument must refer to the first attribute of the
+ * index tuple of which the caller knows that it does not match the scan key:
+ * this means 1 for "no known matching attributes", up to the number of key
+ * attributes + 1 if the caller knows that all key attributes of the index
+ * tuple match those of the scan key.  See backend/access/nbtree/README for
+ * details.
+ *
  * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
  * "minus infinity": this routine will always claim it is less than the
  * scankey.  The actual key value stored is explicitly truncated to 0
@@ -656,7 +724,8 @@ int32
 _bt_compare(Relation rel,
 			BTScanInsert key,
 			Page page,
-			OffsetNumber offnum)
+			OffsetNumber offnum,
+			AttrNumber *compareattr)
 {
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
@@ -696,8 +765,9 @@ _bt_compare(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+
+	scankey = key->scankeys + ((*compareattr) - 1);
+	for (int i = *compareattr; i <= ncmpkey; i++)
 	{
 		Datum		datum;
 		bool		isNull;
@@ -741,11 +811,20 @@ _bt_compare(Relation rel,
 
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
+		{
+			*compareattr = (AttrNumber) i;
 			return result;
+		}
 
 		scankey++;
 	}
 
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*compareattr = ntupatts + 1;
+
 	/*
 	 * All non-truncated attributes (other than heap TID) were found to be
 	 * equal.  Treat truncated attributes as minus infinity when scankey has a
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 7bfbf3086c..ae4e902ad0 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1237,11 +1237,10 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
  */
 extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
 						  Buffer *bufP, int access);
-extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
-							Buffer buf, bool forupdate, BTStack stack,
-							int access);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highkeyprefix);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *compareattr);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost);
-- 
2.40.1

From 81e1efa79d206847f4428813aac303bfaecb64e4 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:57:21 +0100
Subject: [PATCH v14 4/7] btree: Use attribute iterators specialized on key
 shape

This is committed separately to make clear what substantial changes were
made to the pre-existing code.

Even though not all nbt*_spec functions have been updated; these functions
can now directly call (and inline, and optimize for) the specialized functions
they call, instead of having to determine the right specialization based on
the (potentially locally unavailable) index relation, making the specialization
of those functions still worth specializing/duplicating.
---
 src/backend/access/nbtree/nbtsearch_spec.c    | 18 +++---
 src/backend/access/nbtree/nbtsort_spec.c      | 24 +++----
 src/backend/access/nbtree/nbtutils_spec.c     | 62 ++++++++++++-------
 .../utils/sort/tuplesortvariants_spec.c       | 53 +++++++++-------
 4 files changed, 92 insertions(+), 65 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index 09621501ea..47e6e4b9fc 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -678,6 +678,7 @@ _bt_compare(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -710,23 +711,26 @@ _bt_compare(Relation rel,
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
 
 	scankey = key->scankeys + ((*compareattr) - 1);
-	for (int i = *compareattr; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, *compareattr, itupdesc);
+
+	nbts_foreachattr(*compareattr, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
@@ -755,7 +759,7 @@ _bt_compare(Relation rel,
 		/* if the keys are unequal, return the difference */
 		if (result != 0)
 		{
-			*compareattr = (AttrNumber) i;
+			*compareattr = nbts_attiter_attnum;
 			return result;
 		}
 
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index 368d6f244c..6f33cc4cc2 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -34,8 +34,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -57,7 +56,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -90,21 +89,24 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 			else if (itup != NULL)
 			{
 				int32		compare = 0;
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index b411b01ced..6d0a528f9d 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -64,7 +64,7 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -95,7 +95,10 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 				   BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -106,27 +109,30 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -708,6 +714,8 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -719,20 +727,22 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -740,6 +750,7 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -780,24 +791,27 @@ _bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 705da09329..cf262eee2d 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -66,47 +66,54 @@ comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
 	bool		equal_hasnull = false;
 	int			nkey;
 	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
 
 	tuple1 = (IndexTuple) a->tuple;
 	tuple2 = (IndexTuple) b->tuple;
 	keysz = base->nKeys;
 	tupDes = RelationGetDescr(arg->index.indexRel);
 
-	if (sortKey->abbrev_converter)
+	if (!sortKey->abbrev_converter)
 	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
+		nkey = 2;
+		sortKey++;
+	}
+	else
+	{
+		nkey = 1;
 	}
 
 	/* they are equal, so we only need to examine one null flag */
 	if (a->isnull1)
 		equal_hasnull = true;
 
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
 	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+		Datum	datum1,
+				datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		else
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
 
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
 		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
+			return compare;
 
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
+		if (nbts_attiter_curattisnull(tuple1))
 			equal_hasnull = true;
+
+		sortKey++;
 	}
 
 	/*
-- 
2.40.1

From 02f2397320bc55e764a9a92467c92f8aa2f6986b Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:13:04 +0100
Subject: [PATCH v14 3/7] btree: Specialize various performance-sensitive
 functions on btree key shape.

nbtree keys are not all made the same, and a significant amount of time is
spent in code that exists only to deal with various key shapes. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, and splits the code that can
benefit from attribute offset optimizations into separate files. This does
NOT yet update the code itself - it just makes the code compile cleanly.
The performance should be comparable if not the same.
---
 contrib/amcheck/verify_nbtree.c               |    7 +
 src/backend/access/nbtree/README              |   28 +
 src/backend/access/nbtree/nbtdedup.c          |  300 +----
 src/backend/access/nbtree/nbtdedup_spec.c     |  317 +++++
 src/backend/access/nbtree/nbtinsert.c         |  566 +-------
 src/backend/access/nbtree/nbtinsert_spec.c    |  584 ++++++++
 src/backend/access/nbtree/nbtpage.c           |    1 +
 src/backend/access/nbtree/nbtree.c            |   37 +-
 src/backend/access/nbtree/nbtree_spec.c       |   69 +
 src/backend/access/nbtree/nbtsearch.c         | 1182 +---------------
 src/backend/access/nbtree/nbtsearch_spec.c    | 1195 +++++++++++++++++
 src/backend/access/nbtree/nbtsort.c           |  264 +---
 src/backend/access/nbtree/nbtsort_spec.c      |  280 ++++
 src/backend/access/nbtree/nbtsplitloc.c       |    3 +
 src/backend/access/nbtree/nbtutils.c          |  787 +----------
 src/backend/access/nbtree/nbtutils_spec.c     |  808 +++++++++++
 src/backend/utils/sort/tuplesortvariants.c    |  156 +--
 .../utils/sort/tuplesortvariants_spec.c       |  175 +++
 src/include/access/nbtree.h                   |   41 +-
 src/include/access/nbtree_spec.h              |  183 +++
 src/include/access/nbtree_specfuncs.h         |   61 +
 src/tools/pginclude/cpluspluscheck            |    2 +
 src/tools/pginclude/headerscheck              |    2 +
 23 files changed, 3767 insertions(+), 3281 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.c
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.c
 create mode 100644 src/backend/access/nbtree/nbtree_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.c
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.c
 create mode 100644 src/backend/utils/sort/tuplesortvariants_spec.c
 create mode 100644 src/include/access/nbtree_spec.h
 create mode 100644 src/include/access/nbtree_specfuncs.h

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 40fc0a8af7..dd39fb9a81 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -1295,6 +1295,7 @@ bt_target_page_check(BtreeCheckState *state)
 	OffsetNumber offset;
 	OffsetNumber max;
 	BTPageOpaque topaque;
+	nbts_prep_ctx(state->rel);
 
 	/* last visible entry info for checking indexes with unique constraint */
 	int			lVis_i = -1;	/* the position of last visible item for
@@ -2995,6 +2996,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 	BTStack		stack;
 	Buffer		lbuf;
 	bool		exists;
+	nbts_prep_ctx(NULL);
 
 	key = _bt_mkscankey(state->rel, itup);
 	Assert(key->heapkeyspace && key->scantid != NULL);
@@ -3095,6 +3097,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	compareattr = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -3158,6 +3161,7 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	compareattr = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -3182,6 +3186,7 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	int32		cmp;
 	AttrNumber	compareattr = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -3221,6 +3226,7 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 	ItemId		itemid;
 	int32		cmp;
 	AttrNumber	compareattr = 1;
+	nbts_prep_ctx(NULL);
 
 	Assert(key->pivotsearch);
 
@@ -3456,6 +3462,7 @@ static inline BTScanInsert
 bt_mkscankey_pivotsearch(Relation rel, IndexTuple itup)
 {
 	BTScanInsert skey;
+	nbts_prep_ctx(NULL);
 
 	skey = _bt_mkscankey(rel, itup);
 	skey->pivotsearch = true;
diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 0aeee328f1..516b2c25ed 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1098,6 +1098,34 @@ that need a page split anyway.  Besides, supporting variable "split points"
 while splitting posting lists won't actually improve overall space
 utilization.
 
+Notes about nbtree specialization
+---------------------------------
+
+Attribute iteration is a significant overhead for multi-column indexes
+with variable length attributes, due to our inability to cache the offset
+of each attribute into an on-disk tuple. To combat this, we'd have to either
+fully deserialize the tuple, or maintain our offset into the tuple as we
+iterate over the tuple's fields.
+
+Keeping track of this offset also has a non-negligible overhead too, so we'd
+prefer to not have to keep track of these offsets when we can use the cache.
+By specializing performance-sensitive search functions for these specific
+index tuple shapes and calling those selectively, we can keep the performance
+of cacheable attribute offsets where that is applicable, while improving
+performance where we currently would see O(n_atts^2) time iterating on
+variable-length attributes.  Additionally, we update the entry points
+in the index AM to call the specialized functions, increasing the
+performance of those hot paths.
+
+Optimized code paths exist for the following cases, in order of preference:
+ - multi-column indexes that could benefit from the attcacheoff optimization
+   NB: This is also the default path, and is comparatively slow for uncachable
+   attribute offsets.
+
+Future work will optimize for multi-column indexes that don't benefit
+from the attcacheoff optimization by improving on the O(n^2) nature of
+index_getattr through storing attribute offsets.
+
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index d4db0b28f2..4589ade267 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,260 +22,14 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
-			   bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple and add it to our temp page (newpage).
-			 * Else add pending interval's base tuple to the temp page as-is.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place, when this page's newly allocated right sibling page
-				 * gets its first deduplication pass).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtdedup_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -316,6 +70,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 	TM_IndexDeleteOp delstate;
 	bool		neverdedup;
 	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	nbts_prep_ctx(rel);
 
 	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
 	newitemsz += sizeof(ItemIdData);
@@ -752,55 +507,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
new file mode 100644
index 0000000000..4b280de980
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -0,0 +1,317 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtdedup_spec.c
+ *	  Index shape-specialized functions for nbtdedup.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtdedup_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_do_singleval NBTS_FUNCTION(_bt_do_singleval)
+
+static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
+							 OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
+			   bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				minoff,
+				maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+				 _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple and add it to our temp page (newpage).
+			 * Else add pending interval's base tuple to the temp page as-is.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place, when this page's newly allocated right sibling page
+				 * gets its first deduplication pass).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+_bt_do_singleval(Relation rel, Page page, BTDedupState state,
+				 OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index b9f2580c1d..906f66ded8 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,18 +30,10 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, Relation heaprel,
-								 BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
 static void _bt_stepright(Relation rel, Relation heaprel,
 						  BTInsertState insertstate, BTStack stack);
 static void _bt_insertonpg(Relation rel, Relation heaprel, BTScanInsert itup_key,
@@ -75,313 +67,8 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, heapRel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
-					   stack, itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-			AttrNumber	prefix = 1;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
-							&prefix) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
-
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
-					  BT_WRITE);
-}
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtinsert_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -425,6 +112,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	bool		inposting = false;
 	bool		prevalldead = true;
 	int			curposti = 0;
+	nbts_prep_ctx(rel);
 
 	/* Assume unique until we find a duplicate */
 	*is_unique = true;
@@ -777,252 +465,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 }
 
 
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				AttrNumber	cmpatt = 1;
-
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpatt) <= 0)
-					break;
-
-				_bt_stepright(rel, heapRel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			AttrNumber	cmpatt = 1;
-
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpatt) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, heapRel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	{
-		AttrNumber	cmpatt PG_USED_FOR_ASSERTS_ONLY = 1;
-		Assert(P_RIGHTMOST(opaque) ||
-			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpatt) <= 0);
-	}
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
@@ -1506,6 +948,7 @@ _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
 	bool		newitemonleft,
 				isleaf,
 				isrightmost;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * origpage is the original page to be split.  leftpage is a temporary
@@ -2706,6 +2149,7 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 	BTScanInsert itup_key = insertstate->itup_key;
 	Page		page = BufferGetPage(buffer);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
+	nbts_prep_ctx(rel);
 
 	Assert(P_ISLEAF(opaque));
 	Assert(simpleonly || itup_key->heapkeyspace);
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
new file mode 100644
index 0000000000..e3a1a14733
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -0,0 +1,584 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtinsert_spec.c
+ *	  Index shape-specialized functions for nbtinsert.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtinsert_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_search_insert NBTS_FUNCTION(_bt_search_insert)
+#define _bt_findinsertloc NBTS_FUNCTION(_bt_findinsertloc)
+
+static BTStack _bt_search_insert(Relation rel, Relation heaprel,
+								 BTInsertState insertstate);
+static OffsetNumber _bt_findinsertloc(Relation rel,
+									  BTInsertState insertstate,
+									  bool checkingunique,
+									  bool indexUnchanged,
+									  BTStack stack,
+									  Relation heapRel);
+
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+_bt_doinsert(Relation rel, IndexTuple itup,
+			 IndexUniqueCheck checkUnique, bool indexUnchanged,
+			 Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = _bt_mkscankey(rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = _bt_search_insert(rel, heapRel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
+									   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
+					   stack, itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+			AttrNumber	prefix = 1;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY,
+							&prefix) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
+					  BT_WRITE);
+}
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+_bt_findinsertloc(Relation rel,
+				  BTInsertState insertstate,
+				  bool checkingunique,
+				  bool indexUnchanged,
+				  BTStack stack,
+				  Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				AttrNumber	cmpatt = 1;
+
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					_bt_compare(rel, itup_key, page, P_HIKEY, &cmpatt) <= 0)
+					break;
+
+				_bt_stepright(rel, heapRel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			AttrNumber	cmpatt = 1;
+
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				_bt_compare(rel, itup_key, page, P_HIKEY, &cmpatt) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, heapRel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	{
+		AttrNumber	cmpatt PG_USED_FOR_ASSERTS_ONLY = 1;
+		Assert(P_RIGHTMOST(opaque) ||
+			   _bt_compare(rel, itup_key, page, P_HIKEY, &cmpatt) <= 0);
+	}
+
+	newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = _bt_binsrch_insert(rel, insertstate, 1);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index b7660a459e..493f684e83 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1810,6 +1810,7 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 	bool		rightsib_empty;
 	Page		page;
 	BTPageOpaque opaque;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Save original leafbuf block number from caller.  Only deleted blocks
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index a88b36a589..282c4398d5 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,8 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtree_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -121,7 +123,7 @@ bthandler(PG_FUNCTION_ARGS)
 
 	amroutine->ambuild = btbuild;
 	amroutine->ambuildempty = btbuildempty;
-	amroutine->aminsert = btinsert;
+	amroutine->aminsert = btinsert_default;
 	amroutine->ambulkdelete = btbulkdelete;
 	amroutine->amvacuumcleanup = btvacuumcleanup;
 	amroutine->amcanreturn = btcanreturn;
@@ -155,6 +157,8 @@ btbuildempty(Relation index)
 	Buffer		metabuf;
 	Page		metapage;
 
+	nbt_opt_specialize(index);
+
 	/*
 	 * Initalize the metapage.
 	 *
@@ -180,33 +184,6 @@ btbuildempty(Relation index)
 	ReleaseBuffer(metabuf);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
@@ -348,6 +325,8 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	BTScanOpaque so;
 
+	nbt_opt_specialize(rel);
+
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
 
@@ -793,6 +772,8 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
 
+	nbt_opt_specialize(rel);
+
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
 		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
new file mode 100644
index 0000000000..6b766581ab
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -0,0 +1,69 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_spec.c
+ *	  Index shape-specialized functions for nbtree.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtree_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+_bt_specialize(Relation rel)
+{
+#ifdef NBTS_SPECIALIZING_DEFAULT
+	NBTS_MAKE_CTX(rel);
+	/*
+	 * We can't directly address _bt_specialize here because it'd be macro-
+	 * expanded, nor can we utilize NBTS_SPECIALIZE_NAME here because it'd
+	 * try to call _bt_specialize, which would be an infinite recursive call.
+	 */
+	switch (__nbts_ctx) {
+		case NBTS_CTX_CACHED:
+			_bt_specialize_cached(rel);
+			break;
+		case NBTS_CTX_DEFAULT:
+			break;
+	}
+#else
+	rel->rd_indam->aminsert = btinsert;
+#endif
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+btinsert(Relation rel, Datum *values, bool *isnull,
+		 ItemPointer ht_ctid, Relation heapRel,
+		 IndexUniqueCheck checkUnique,
+		 bool indexUnchanged,
+		 IndexInfo *indexInfo)
+{
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index 6dac8169a5..d6b847f506 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -26,16 +26,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
-								AttrNumber *rsepcmpcol);
-static Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
-							Buffer buf, bool forupdate, BTStack stack,
-							int access, AttrNumber *prefix,
-							IndexTuple rightsep);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -52,6 +44,8 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsearch_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -76,606 +70,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- *
- * heaprel must be provided by callers that pass access = BT_WRITE, since we
- * might need to allocate a new root page for caller -- see _bt_allocbuf.
- */
-BTStack
-_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
-		   int access)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-	union {
-		char	data[MAXALIGN_DOWN(BLCKSZ / 3)];
-		IndexTupleData tuple;
-		double	_align;
-	}			rsepbuf;
-	IndexTuple	rightsep = NULL;
-	AttrNumber	highkeyprefix = 1;
-
-	/* heaprel must be set whenever _bt_allocbuf is reachable */
-	Assert(access == BT_READ || access == BT_WRITE);
-	Assert(access == BT_READ || heaprel != NULL);
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, heaprel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access, &highkeyprefix, rightsep);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP, &highkeyprefix);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		if (offnum < PageGetMaxOffsetNumber(page))
-		{
-			ItemId	rightsepitem = PageGetItemId(page, offnum + 1);
-			IndexTuple pagerightsep = (IndexTuple) PageGetItem(page, rightsepitem);
-			memcpy(rsepbuf.data, pagerightsep, ItemIdGetLength(rightsepitem));
-			rightsep = &rsepbuf.tuple;
-		}
-		else if (!P_RIGHTMOST(opaque))
-		{
-			/*
-			 * The rightmost data tuple on inner page has P_HIKEY as its right
-			 * separator.
-			 */
-			ItemId	rightsepitem = PageGetItemId(page, P_HIKEY);
-			IndexTuple pagerightsep = (IndexTuple) PageGetItem(page, rightsepitem);
-			memcpy(rsepbuf.data, pagerightsep, ItemIdGetLength(rightsepitem));
-			rightsep = &rsepbuf.tuple;
-		}
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		highkeyprefix = 1;
-
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
-							  &highkeyprefix, rightsep);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split is
- * completed.  'heaprel' and 'stack' are only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- *
- * On exit, we've updated *comparecol with the prefix that the high key shares
- */
-Buffer
-_bt_moveright(Relation rel,
-			  Relation heaprel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access,
-			  AttrNumber *prefix,
-			  IndexTuple rightsep)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	Assert(!forupdate || heaprel != NULL);
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 *
-	 * Note: It is important that *comparecol is set to an accurate value at
-	 * return. Rightmost pages have no prefix, thus set it to 1.  In all other
-	 * cases, it must be updated with the prefix result of this page's
-	 * HIGHKEY's full _bt_compare.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		/*
-		 * We explicitly don't reuse the prefix argument of this function,
-		 * as we may need to move multiple times, and we don't want to
-		 * overwrite the value stored in *prefix if we could reuse it.
-		 * Additionally, its value will be useless for any of our own
-		 * _bt_compare calls: only if the downlink right separator/HIKEY
-		 * optimization is applicable we can use the value, and when it is
-		 * applicable then we don't have to call _bt_compare.
-		 */
-		AttrNumber	prefixatt = 1;
-
-		page = BufferGetPage(buf);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-		{
-			/* set the compare column when breaking out of the loop */
-			*prefix = 1;
-			break;
-		}
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, heaprel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		if (P_IGNORE(opaque))
-		{
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-
-		if (PointerIsValid(rightsep))
-		{
-			ItemId	hikeyid = PageGetItemId(page, P_HIKEY);
-			IndexTuple highkey = (IndexTuple) PageGetItem(page, hikeyid);
-
-			if (ItemIdGetLength(hikeyid) == IndexTupleSize(rightsep) &&
-				memcmp(&highkey[1], &rightsep[1],
-					   IndexTupleSize(rightsep) - sizeof(IndexTupleData)) == 0)
-			{
-				/*
-				 * *comparecol contains the _bt_compare(... &comparecol)
-				 * result for rightsep, no need to update it
-				 */
-				break;
-			}
-		}
-
-		if (_bt_compare(rel, key, page, P_HIKEY, &prefixatt) >= cmpval)
-		{
-			/* set the compare column when breaking out of the loop */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-		{
-			/* make sure to set the compare column */
-			*prefix = prefixatt;
-			break;
-		}
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
- * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
- * particular, this means it is possible to return a value 1 greater than the
- * number of keys on the page, if the scankey is > all keys on the page.)
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)  This key indicates the
- * right place to descend to be sure we find all leaf keys >= given scankey
- * (or leaf keys > given scankey when nextkey is true).
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf,
-			AttrNumber *rsepcmpcol)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-	/*
-	 * Prefix bounds, for the high/low offset's compare columns.
-	 * "highkeyprefix" is the value for this page's high key (if any) or 1
-	 * (no established shared prefix)
-	 */
-	AttrNumber	highkeyprefix = *rsepcmpcol,
-				lowkeyprefix = 1;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have children).
-	 */
-	if (unlikely(high < low))
-	{
-		/* Prefixes don't make much sense in empty pages, so just reset it */
-		*rsepcmpcol = 1;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We maintain highkeyprefix and lowkeyprefix to keep track of prefixes
-	 * that tuples share with the scan key, potentially allowing us to skip a
-	 * prefix in the midpoint comparison.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber	prefix = Min(highkeyprefix, lowkeyprefix); /* update prefix bounds */
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &prefix);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowkeyprefix = prefix;
-		}
-		else
-		{
-			high = mid;
-			highkeyprefix = prefix;
-		}
-	}
-
-	*rsepcmpcol = highkeyprefix;
-
-	/*
-	 * At this point we have high == low, but be careful: they could point
-	 * past the last slot on the page.
-	 *
-	 * On a leaf page, we always return the first key >= scan key (resp. >
-	 * scan key), which could be the last slot + 1.
-	 */
-	if (P_ISLEAF(opaque))
-		return low;
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-				   AttrNumber highkeyprefix)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-	AttrNumber	lowkeyprefix = 1;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-		AttrNumber	prefix = Min(highkeyprefix, lowkeyprefix);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid, &prefix);
-
-		if (result >= cmpval)
-		{
-			low = mid + 1;
-			lowkeyprefix = prefix;
-		}
-		else
-		{
-			high = mid;
-			highkeyprefix = prefix;
-
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
-
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
  *
@@ -743,235 +137,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * NOTE: The "comparecol" argument must refer to the first attribute of the
- * index tuple of which the caller knows that it does not match the scan key:
- * this means 1 for "no known matching attributes", up to the number of key
- * attributes + 1 if the caller knows that all key attributes of the index
- * tuple match those of the scan key.  See backend/access/nbtree/README for
- * details.
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum,
-			AttrNumber *compareattr)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-
-	scankey = key->scankeys + ((*compareattr) - 1);
-	for (int i = *compareattr; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-		{
-			*compareattr = (AttrNumber) i;
-			return result;
-		}
-
-		scankey++;
-	}
-
-	/*
-	 * All tuple attributes are equal to the scan key, only later attributes
-	 * could potentially not equal the scan key.
-	 */
-	*compareattr = ntupatts + 1;
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Most searches have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * However, some searches (pivotsearch searches) actually require that
-		 * we descend left when this happens.  -inf is treated as a possible
-		 * match for omitted scankey attribute(s).  This is needed by page
-		 * deletion, which must re-find leaf pages that are targets for
-		 * deletion using their high keys.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated key
-		 * attributes.
-		 *
-		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
-		 * left here, since they have no heap TID attribute (and cannot have
-		 * any -inf key values in any case, since truncation can only remove
-		 * non-key attributes).  !heapkeyspace searches must always be
-		 * prepared to deal with matches on both sides of the pivot once the
-		 * leaf level is reached.
-		 */
-		if (key->heapkeyspace && !key->pivotsearch &&
-			key->keysz == ntupatts && heapTid == NULL)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -1012,6 +177,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	nbts_prep_ctx(rel);
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -1650,342 +816,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-	bool		requiredMatchedByPrecheck;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	/*
-	 * Prechecking the page with scan keys required for direction scan.  We
-	 * check these keys with the last item on the page (according to our scan
-	 * direction).  If these keys are matched, we can skip checking them with
-	 * every item on the page.  Scan keys for our scan direction would
-	 * necessarily match the previous items.  Scan keys required for opposite
-	 * direction scan are already matched by the _bt_first() call.
-	 *
-	 * With the forward scan, we do this check for the last item on the page
-	 * instead of the high key.  It's relatively likely that the most
-	 * significant column in the high key will be different from the
-	 * corresponding value from the last item on the page.  So checking with
-	 * the last item on the page would give a more precise answer.
-	 *
-	 * We skip this for the first page in the scan to evade the possible
-	 * slowdown of the point queries.
-	 */
-	if (!so->firstPage && minoff < maxoff)
-	{
-		ItemId		iid;
-		IndexTuple	itup;
-
-		iid = PageGetItemId(page, ScanDirectionIsForward(dir) ? maxoff : minoff);
-		itup = (IndexTuple) PageGetItem(page, iid);
-
-		/*
-		 * Do the precheck.  Note that we pass the pointer to
-		 * 'requiredMatchedByPrecheck' to 'continuescan' argument.  That will
-		 * set flag to true if all required keys are satisfied and false
-		 * otherwise.
-		 */
-		(void) _bt_checkkeys(scan, itup, indnatts, dir,
-							 &requiredMatchedByPrecheck, false);
-	}
-	else
-	{
-		so->firstPage = false;
-		requiredMatchedByPrecheck = false;
-	}
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan, requiredMatchedByPrecheck);
-
-			/*
-			 * If the result of prechecking required keys was true, then in
-			 * assert-enabled builds we also recheck that the _bt_checkkeys()
-			 * result is the same.
-			 */
-			Assert(!requiredMatchedByPrecheck ||
-				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
-												 &continuescan, false));
-			if (passes_quals)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan, false);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan, requiredMatchedByPrecheck);
-
-			/*
-			 * If the result of prechecking required keys was true, then in
-			 * assert-enabled builds we also recheck that the _bt_checkkeys()
-			 * result is the same.
-			 */
-			Assert(!requiredMatchedByPrecheck ||
-				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
-												 &continuescan, false));
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2194,12 +1024,11 @@ static bool
 _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 {
 	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Relation	rel;
+	Relation	rel = scan->indexRelation;
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
-
-	rel = scan->indexRelation;
+	nbts_prep_ctx(rel);
 
 	if (ScanDirectionIsForward(dir))
 	{
@@ -2601,6 +1430,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	BTPageOpaque opaque;
 	OffsetNumber start;
 	BTScanPosItem *currItem;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Scan down to the leftmost or rightmost leaf page.  This is a simplified
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
new file mode 100644
index 0000000000..09621501ea
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -0,0 +1,1195 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsearch_spec.c
+ *	  Index shape-specialized functions for nbtsearch.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsearch_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_binsrch		NBTS_FUNCTION(_bt_binsrch)
+#define _bt_moveright	NBTS_FUNCTION(_bt_moveright)
+#define _bt_readpage	NBTS_FUNCTION(_bt_readpage)
+
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf,
+								AttrNumber *rsepcmpcol);
+static Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
+							Buffer buf, bool forupdate, BTStack stack,
+							int access, AttrNumber *prefix,
+							IndexTuple rightsep);
+static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
+						 OffsetNumber offnum);
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ *
+ * heaprel must be provided by callers that pass access = BT_WRITE, since we
+ * might need to allocate a new root page for caller -- see _bt_allocbuf.
+ */
+BTStack
+_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
+		   int access)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+	union {
+		char	data[MAXALIGN_DOWN(BLCKSZ / 3)];
+		IndexTupleData tuple;
+		double	_align;
+	}			rsepbuf;
+	IndexTuple	rightsep = NULL;
+	AttrNumber	highkeyprefix = 1;
+
+	/* heaprel must be set whenever _bt_allocbuf is reachable */
+	Assert(access == BT_READ || access == BT_WRITE);
+	Assert(access == BT_READ || heaprel != NULL);
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, heaprel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
+							  stack_in, page_access, &highkeyprefix, rightsep);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = _bt_binsrch(rel, key, *bufP, &highkeyprefix);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		if (offnum < PageGetMaxOffsetNumber(page))
+		{
+			ItemId	rightsepitem = PageGetItemId(page, offnum + 1);
+			IndexTuple pagerightsep = (IndexTuple) PageGetItem(page, rightsepitem);
+			memcpy(rsepbuf.data, pagerightsep, ItemIdGetLength(rightsepitem));
+			rightsep = &rsepbuf.tuple;
+		}
+		else if (!P_RIGHTMOST(opaque))
+		{
+			/*
+			 * The rightmost data tuple on inner page has P_HIKEY as its right
+			 * separator.
+			 */
+			ItemId	rightsepitem = PageGetItemId(page, P_HIKEY);
+			IndexTuple pagerightsep = (IndexTuple) PageGetItem(page, rightsepitem);
+			memcpy(rsepbuf.data, pagerightsep, ItemIdGetLength(rightsepitem));
+			rightsep = &rsepbuf.tuple;
+		}
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		highkeyprefix = 1;
+
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE,
+							  &highkeyprefix, rightsep);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split is
+ * completed.  'heaprel' and 'stack' are only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ *
+ * On exit, we've updated *comparecol with the prefix that the high key shares
+ */
+Buffer
+_bt_moveright(Relation rel,
+			  Relation heaprel,
+			  BTScanInsert key,
+			  Buffer buf,
+			  bool forupdate,
+			  BTStack stack,
+			  int access,
+			  AttrNumber *prefix,
+			  IndexTuple rightsep)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	Assert(!forupdate || heaprel != NULL);
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 *
+	 * Note: It is important that *comparecol is set to an accurate value at
+	 * return. Rightmost pages have no prefix, thus set it to 1.  In all other
+	 * cases, it must be updated with the prefix result of this page's
+	 * HIGHKEY's full _bt_compare.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		/*
+		 * We explicitly don't reuse the prefix argument of this function,
+		 * as we may need to move multiple times, and we don't want to
+		 * overwrite the value stored in *prefix if we could reuse it.
+		 * Additionally, its value will be useless for any of our own
+		 * _bt_compare calls: only if the downlink right separator/HIKEY
+		 * optimization is applicable we can use the value, and when it is
+		 * applicable then we don't have to call _bt_compare.
+		 */
+		AttrNumber	prefixatt = 1;
+
+		page = BufferGetPage(buf);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+		{
+			/* set the compare column when breaking out of the loop */
+			*prefix = 1;
+			break;
+		}
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, heaprel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		if (P_IGNORE(opaque))
+		{
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+
+		if (PointerIsValid(rightsep))
+		{
+			ItemId	hikeyid = PageGetItemId(page, P_HIKEY);
+			IndexTuple highkey = (IndexTuple) PageGetItem(page, hikeyid);
+
+			if (ItemIdGetLength(hikeyid) == IndexTupleSize(rightsep) &&
+				memcmp(&highkey[1], &rightsep[1],
+					   IndexTupleSize(rightsep) - sizeof(IndexTupleData)) == 0)
+			{
+				/*
+				 * *comparecol contains the _bt_compare(... &comparecol)
+				 * result for rightsep, no need to update it
+				 */
+				break;
+			}
+		}
+
+		if (_bt_compare(rel, key, page, P_HIKEY, &prefixatt) >= cmpval)
+		{
+			/* set the compare column when breaking out of the loop */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+		{
+			/* make sure to set the compare column */
+			*prefix = prefixatt;
+			break;
+		}
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On a leaf page, _bt_binsrch() returns the OffsetNumber of the first
+ * key >= given scankey, or > scankey if nextkey is true.  (NOTE: in
+ * particular, this means it is possible to return a value 1 greater than the
+ * number of keys on the page, if the scankey is > all keys on the page.)
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)  This key indicates the
+ * right place to descend to be sure we find all leaf keys >= given scankey
+ * (or leaf keys > given scankey when nextkey is true).
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+_bt_binsrch(Relation rel,
+			BTScanInsert key,
+			Buffer buf,
+			AttrNumber *rsepcmpcol)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+	/*
+	 * Prefix bounds, for the high/low offset's compare columns.
+	 * "highkeyprefix" is the value for this page's high key (if any) or 1
+	 * (no established shared prefix)
+	 */
+	AttrNumber	highkeyprefix = *rsepcmpcol,
+				lowkeyprefix = 1;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have children).
+	 */
+	if (unlikely(high < low))
+	{
+		/* Prefixes don't make much sense in empty pages, so just reset it */
+		*rsepcmpcol = 1;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We maintain highkeyprefix and lowkeyprefix to keep track of prefixes
+	 * that tuples share with the scan key, potentially allowing us to skip a
+	 * prefix in the midpoint comparison.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	prefix = Min(highkeyprefix, lowkeyprefix); /* update prefix bounds */
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &prefix);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowkeyprefix = prefix;
+		}
+		else
+		{
+			high = mid;
+			highkeyprefix = prefix;
+		}
+	}
+
+	*rsepcmpcol = highkeyprefix;
+
+	/*
+	 * At this point we have high == low, but be careful: they could point
+	 * past the last slot on the page.
+	 *
+	 * On a leaf page, we always return the first key >= scan key (resp. >
+	 * scan key), which could be the last slot + 1.
+	 */
+	if (P_ISLEAF(opaque))
+		return low;
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+				   AttrNumber highkeyprefix)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+	AttrNumber	lowkeyprefix = 1;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+		AttrNumber	prefix = Min(highkeyprefix, lowkeyprefix);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid, &prefix);
+
+		if (result >= cmpval)
+		{
+			low = mid + 1;
+			lowkeyprefix = prefix;
+		}
+		else
+		{
+			high = mid;
+			highkeyprefix = prefix;
+
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+										 ItemPointerGetBlockNumber(key->scantid),
+										 ItemPointerGetOffsetNumber(key->scantid),
+										 low, stricthigh,
+										 BufferGetBlockNumber(insertstate->buf),
+										 RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * NOTE: The "comparecol" argument must refer to the first attribute of the
+ * index tuple of which the caller knows that it does not match the scan key:
+ * this means 1 for "no known matching attributes", up to the number of key
+ * attributes + 1 if the caller knows that all key attributes of the index
+ * tuple match those of the scan key.  See backend/access/nbtree/README for
+ * details.
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+_bt_compare(Relation rel,
+			BTScanInsert key,
+			Page page,
+			OffsetNumber offnum,
+			AttrNumber *compareattr)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+
+	scankey = key->scankeys + ((*compareattr) - 1);
+	for (int i = *compareattr; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+		{
+			*compareattr = (AttrNumber) i;
+			return result;
+		}
+
+		scankey++;
+	}
+
+	/*
+	 * All tuple attributes are equal to the scan key, only later attributes
+	 * could potentially not equal the scan key.
+	 */
+	*compareattr = ntupatts + 1;
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Most searches have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * However, some searches (pivotsearch searches) actually require that
+		 * we descend left when this happens.  -inf is treated as a possible
+		 * match for omitted scankey attribute(s).  This is needed by page
+		 * deletion, which must re-find leaf pages that are targets for
+		 * deletion using their high keys.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated key
+		 * attributes.
+		 *
+		 * Note: pg_upgrade'd !heapkeyspace indexes must always descend to the
+		 * left here, since they have no heap TID attribute (and cannot have
+		 * any -inf key values in any case, since truncation can only remove
+		 * non-key attributes).  !heapkeyspace searches must always be
+		 * prepared to deal with matches on both sides of the pivot once the
+		 * leaf level is reached.
+		 */
+		if (key->heapkeyspace && !key->pivotsearch &&
+			key->keysz == ntupatts && heapTid == NULL)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+	bool		requiredMatchedByPrecheck;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	/*
+	 * Prechecking the page with scan keys required for direction scan.  We
+	 * check these keys with the last item on the page (according to our scan
+	 * direction).  If these keys are matched, we can skip checking them with
+	 * every item on the page.  Scan keys for our scan direction would
+	 * necessarily match the previous items.  Scan keys required for opposite
+	 * direction scan are already matched by the _bt_first() call.
+	 *
+	 * With the forward scan, we do this check for the last item on the page
+	 * instead of the high key.  It's relatively likely that the most
+	 * significant column in the high key will be different from the
+	 * corresponding value from the last item on the page.  So checking with
+	 * the last item on the page would give a more precise answer.
+	 *
+	 * We skip this for the first page in the scan to evade the possible
+	 * slowdown of the point queries.
+	 */
+	if (!so->firstPage && minoff < maxoff)
+	{
+		ItemId		iid;
+		IndexTuple	itup;
+
+		iid = PageGetItemId(page, ScanDirectionIsForward(dir) ? maxoff : minoff);
+		itup = (IndexTuple) PageGetItem(page, iid);
+
+		/*
+		 * Do the precheck.  Note that we pass the pointer to
+		 * 'requiredMatchedByPrecheck' to 'continuescan' argument.  That will
+		 * set flag to true if all required keys are satisfied and false
+		 * otherwise.
+		 */
+		(void) _bt_checkkeys(scan, itup, indnatts, dir,
+							 &requiredMatchedByPrecheck, false);
+	}
+	else
+	{
+		so->firstPage = false;
+		requiredMatchedByPrecheck = false;
+	}
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan, requiredMatchedByPrecheck);
+
+			/*
+			 * If the result of prechecking required keys was true, then in
+			 * assert-enabled builds we also recheck that the _bt_checkkeys()
+			 * result is the same.
+			 */
+			Assert(!requiredMatchedByPrecheck ||
+				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
+												 &continuescan, false));
+			if (passes_quals)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan, false);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan, requiredMatchedByPrecheck);
+
+			/*
+			 * If the result of prechecking required keys was true, then in
+			 * assert-enabled builds we also recheck that the _bt_checkkeys()
+			 * result is the same.
+			 */
+			Assert(!requiredMatchedByPrecheck ||
+				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
+												 &continuescan, false));
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index c2665fce41..8742716383 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,8 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtsort_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -544,6 +544,7 @@ static void
 _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 {
 	BTWriteState wstate;
+	nbts_prep_ctx(btspool->index);
 
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
@@ -846,6 +847,7 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 	Size		pgspc;
 	Size		itupsz;
 	bool		isleaf;
+	nbts_prep_ctx(wstate->index);
 
 	/*
 	 * This is a handy place to check for cancel interrupts during the btree
@@ -1178,264 +1180,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			Assert(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
new file mode 100644
index 0000000000..368d6f244c
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -0,0 +1,280 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsort_spec.c
+ *	  Index shape-specialized functions for nbtsort.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsort_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_load NBTS_FUNCTION(_bt_load)
+
+static void _bt_load(BTWriteState *wstate,
+					 BTSpool *btspool, BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			Assert(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
+										 itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index 85834c3dd7..e078c294e2 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -639,6 +639,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	ItemId		itemid;
 	IndexTuple	tup;
 	int			keepnatts;
+	nbts_prep_ctx(state->rel);
 
 	Assert(state->is_leaf && !state->is_rightmost);
 
@@ -945,6 +946,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 			   *rightinterval;
 	int			perfectpenalty;
 	int			indnkeyatts = IndexRelationGetNumberOfKeyAttributes(state->rel);
+	nbts_prep_ctx(state->rel);
 
 	/* Assume that alternative strategy won't be used for now */
 	*strategy = SPLIT_DEFAULT;
@@ -1137,6 +1139,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 {
 	IndexTuple	lastleft;
 	IndexTuple	firstright;
+	nbts_prep_ctx(state->rel);
 
 	if (!state->is_leaf)
 	{
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 1510b97fbe..ffdce2e15f 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,130 +50,10 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
+#define NBT_SPECIALIZE_FILE "../../backend/access/nbtree/nbtutils_spec.c"
+#include "access/nbtree_spec.h"
 
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		When itup is a non-pivot tuple, the returned insertion scan key is
- *		suitable for finding a place for it to go on the leaf level.  Pivot
- *		tuples can be used to re-find leaf page with matching high key, but
- *		then caller needs to set scan key's pivotsearch field to true.  This
- *		allows caller to search for a leaf page with a matching high key,
- *		which is usually to the left of the first leaf page a non-pivot match
- *		might appear on.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;
-	key->pivotsearch = false;
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1355,389 +1235,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- * requiredMatchedByPrecheck: indicates that scan keys required for
- * 							  direction scan are already matched
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan,
-			  bool requiredMatchedByPrecheck)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-		bool		requiredSameDir = false,
-					requiredOppositeDir = false;
-
-		/*
-		 * Check if the key is required for ordered scan in the same or
-		 * opposite direction.  Save as flag variables for future usage.
-		 */
-		if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsForward(dir)) ||
-			((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsBackward(dir)))
-			requiredSameDir = true;
-		else if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsBackward(dir)) ||
-				 ((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsForward(dir)))
-			requiredOppositeDir = true;
-
-		/*
-		 * Is the key required for scanning for either forward or backward
-		 * direction?  If so and caller told us that these types of keys are
-		 * known to be matched, skip the check.  Except for the row keys,
-		 * where NULLs could be found in the middle of matching values.
-		 */
-		if ((requiredSameDir || requiredOppositeDir) &&
-			!(key->sk_flags & SK_ROW_HEADER) && requiredMatchedByPrecheck)
-			continue;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if (requiredSameDir)
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		/*
-		 * Apply the key checking function.  When the key is required for
-		 * opposite direction scan, it must be already satisfied by
-		 * _bt_first() except for the NULLs checking, which have already done
-		 * above.
-		 */
-		if (!requiredOppositeDir)
-		{
-			test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-									 datum, key->sk_argument);
-		}
-		else
-		{
-			test = true;
-			Assert(test == FunctionCall2Coll(&key->sk_func, key->sk_collation,
-											 datum, key->sk_argument));
-		}
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if (requiredSameDir)
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2221,286 +1718,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
new file mode 100644
index 0000000000..b411b01ced
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -0,0 +1,808 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtutils_spec.c
+ *	  Index shape-specialized functions for nbtutils.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtutils_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define _bt_check_rowcompare	NBTS_FUNCTION(_bt_check_rowcompare)
+#define _bt_keep_natts			NBTS_FUNCTION(_bt_keep_natts)
+
+static bool _bt_check_rowcompare(ScanKey skey,
+								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+								 ScanDirection dir, bool *continuescan);
+static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
+							 IndexTuple firstright, BTScanInsert itup_key);
+
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		When itup is a non-pivot tuple, the returned insertion scan key is
+ *		suitable for finding a place for it to go on the leaf level.  Pivot
+ *		tuples can be used to re-find leaf page with matching high key, but
+ *		then caller needs to set scan key's pivotsearch field to true.  This
+ *		allows caller to search for a leaf page with a matching high key,
+ *		which is usually to the left of the first leaf page a non-pivot match
+ *		might appear on.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+_bt_mkscankey(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;
+	key->pivotsearch = false;
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+				   BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ * requiredMatchedByPrecheck: indicates that scan keys required for
+ * 							  direction scan are already matched
+ */
+bool
+_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+			  ScanDirection dir, bool *continuescan,
+			  bool requiredMatchedByPrecheck)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+		bool		requiredSameDir = false,
+					requiredOppositeDir = false;
+
+		/*
+		 * Check if the key is required for ordered scan in the same or
+		 * opposite direction.  Save as flag variables for future usage.
+		 */
+		if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsForward(dir)) ||
+			((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsBackward(dir)))
+			requiredSameDir = true;
+		else if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsBackward(dir)) ||
+				 ((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsForward(dir)))
+			requiredOppositeDir = true;
+
+		/*
+		 * Is the key required for scanning for either forward or backward
+		 * direction?  If so and caller told us that these types of keys are
+		 * known to be matched, skip the check.  Except for the row keys,
+		 * where NULLs could be found in the middle of matching values.
+		 */
+		if ((requiredSameDir || requiredOppositeDir) &&
+			!(key->sk_flags & SK_ROW_HEADER) && requiredMatchedByPrecheck)
+			continue;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
+									 continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if (requiredSameDir)
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		/*
+		 * Apply the key checking function.  When the key is required for
+		 * opposite direction scan, it must be already satisfied by
+		 * _bt_first() except for the NULLs checking, which have already done
+		 * above.
+		 */
+		if (!requiredOppositeDir)
+		{
+			test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+									 datum, key->sk_argument);
+		}
+		else
+		{
+			test = true;
+			Assert(test == FunctionCall2Coll(&key->sk_func, key->sk_collation,
+											 datum, key->sk_argument));
+		}
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if (requiredSameDir)
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
+					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+			/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			 BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			   BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index 2cd508e513..ae247c2457 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -61,10 +61,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int tuplen);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
-static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
-											Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static int	comparetup_index_hash_tiebreak(const SortTuple *a, const SortTuple *b,
@@ -140,6 +136,9 @@ typedef struct
 	int			datumTypeLen;
 } TuplesortDatumArg;
 
+#define NBT_SPECIALIZE_FILE "../../backend/utils/sort/tuplesortvariants_spec.c"
+#include "access/nbtree_spec.h"
+
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
 					 int nkeys, AttrNumber *attNums,
@@ -228,6 +227,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 	MemoryContext oldcontext;
 	TuplesortClusterArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	Assert(indexRel->rd_rel->relam == BTREE_AM_OID);
 
@@ -340,6 +340,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	TuplesortIndexBTreeArg *arg;
 	MemoryContext oldcontext;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -475,6 +476,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 	MemoryContext oldcontext;
 	TuplesortIndexBTreeArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -1299,152 +1301,6 @@ removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
 	}
 }
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	SortSupport sortKey = base->sortKeys;
-	int32		compare;
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	return comparetup_index_btree_tiebreak(a, b, state);
-}
-
-static int
-comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
-								Tuplesortstate *state)
-{
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
-	SortSupport sortKey = base->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = base->nKeys;
-	tupDes = RelationGetDescr(arg->index.indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(arg->index.indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(arg->index.heapRel,
-									RelationGetRelationName(arg->index.indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
new file mode 100644
index 0000000000..705da09329
--- /dev/null
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -0,0 +1,175 @@
+/*-------------------------------------------------------------------------
+ *
+ * tuplesortvariants_spec.c
+ *	  Index shape-specialized functions for tuplesortvariants.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/tuplesortvariants_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define comparetup_index_btree NBTS_FUNCTION(comparetup_index_btree)
+#define comparetup_index_btree_tiebreak NBTS_FUNCTION(comparetup_index_btree_tiebreak)
+
+static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+								   Tuplesortstate *state);
+static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
+											Tuplesortstate *state);
+
+static int
+comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+					   Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	SortSupport sortKey = base->sortKeys;
+	int32		compare;
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	return comparetup_index_btree_tiebreak(a, b, state);
+}
+
+static int
+comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
+								Tuplesortstate *state)
+{	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
+	SortSupport sortKey = base->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	Datum		datum1,
+				datum2;
+	bool		isnull1,
+				isnull2;
+
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = base->nKeys;
+	tupDes = RelationGetDescr(arg->index.indexRel);
+
+	if (sortKey->abbrev_converter)
+	{
+		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
+
+		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
+												datum2, isnull2,
+												sortKey);
+		if (compare != 0)
+			return compare;
+	}
+
+	/* they are equal, so we only need to examine one null flag */
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	sortKey++;
+	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	{
+		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+
+		compare = ApplySortComparator(datum1, isnull1,
+									  datum2, isnull2,
+									  sortKey);
+		if (compare != 0)
+			return compare;		/* done when we find unequal attributes */
+
+		/* they are equal, so we only need to examine one null flag */
+		if (isnull1)
+			equal_hasnull = true;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(arg->index.indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(arg->index.heapRel,
+									   RelationGetRelationName(arg->index.indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index ae4e902ad0..2da051c680 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1126,15 +1126,27 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+typedef enum NBTS_CTX {
+	NBTS_CTX_CACHED, 
+	NBTS_CTX_DEFAULT, /* fallback */
+} NBTS_CTX;
+
+static inline NBTS_CTX _nbt_spec_context(Relation irel)
+{
+	if (!PointerIsValid(irel))
+		return NBTS_CTX_DEFAULT;
+
+	return NBTS_CTX_CACHED;
+}
+
+
+#define NBT_SPECIALIZE_FILE "access/nbtree_specfuncs.h"
+#include "nbtree_spec.h"
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1165,8 +1177,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
-						   Size newitemsz, bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1182,9 +1192,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Relation heaprel, Buffer lbuf,
 							 BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, Relation heaprel, BTStack stack,
@@ -1235,12 +1242,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
-						  Buffer *bufP, int access);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
-									   AttrNumber highkeyprefix);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
-						 OffsetNumber offnum, AttrNumber *compareattr);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost);
@@ -1248,7 +1249,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost);
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1256,9 +1256,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan,
-						  bool requiredMatchedByPrecheck);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1271,10 +1268,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
new file mode 100644
index 0000000000..fa38b09c6e
--- /dev/null
+++ b/src/include/access/nbtree_spec.h
@@ -0,0 +1,183 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those.
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ * - nbts_context(irel)
+ *   Constructs a context that is used to call specialized functions.
+ *   Note that this is unneeded in paths that are inaccessible to unspecialized
+ *   code paths (i.e. code included through nbtree_spec.h), because that
+ *   always calls the optimized functions directly.
+ */
+
+/*
+ * Macros used in the nbtree specialization code.
+ */
+#define NBTS_TYPE_CACHED cached
+#define NBTS_TYPE_DEFAULT default
+#define NBTS_CTX_NAME __nbts_ctx
+
+/* contextual specializations */
+#define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
+#define NBTS_SPECIALIZE_NAME(name) ( \
+	(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+	) \
+)
+
+/* how do we make names? */
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+#define nbt_opt_specialize(rel) \
+do { \
+	Assert(PointerIsValid(rel)); \
+	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
+	{ \
+		nbts_prep_ctx(rel); \
+		_bt_specialize(rel); \
+	} \
+} while (false)
+
+/*
+ * Protections against multiple inclusions - the definition of this macro is
+ * different for files included with the templating mechanism vs the users
+ * of this template, so redefine these macros at top and bottom.
+ */
+#ifdef NBTS_FUNCTION
+#undef NBTS_FUNCTION
+#endif
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+/* While specializing, the context is the local context */
+#ifdef nbts_prep_ctx
+#undef nbts_prep_ctx
+#endif
+#define nbts_prep_ctx(rel)
+
+/*
+ * Specialization 1: CACHED
+ *
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_SPECIALIZING_CACHED
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) do {} while (false)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_SPECIALIZING_CACHED
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * Specialization 2: DEFAULT
+ *
+ * "Default", externally accessible, not so optimized functions
+ */
+
+/* Only the default context may need to specialize in some cases, so here's that */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+#define NBTS_SPECIALIZING_DEFAULT
+#define NBTS_TYPE NBTS_TYPE_DEFAULT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_DEFAULT
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
+/*
+ * All next uses of nbts_prep_ctx are in non-templated code, so here we make
+ * sure we actually create the context.
+ */
+#undef nbts_prep_ctx
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+/*
+ * from here on all NBTS_FUNCTIONs are from specialized function names that
+ * are being called. Change the result of those macros from a direct call
+ * call to a conditional call to the right place, depending on the correct
+ * context.
+ */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) NBTS_SPECIALIZE_NAME(name)
+
+#undef NBT_SPECIALIZE_FILE
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
new file mode 100644
index 0000000000..c7776741c3
--- /dev/null
+++ b/src/include/access/nbtree_specfuncs.h
@@ -0,0 +1,61 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+#define _bt_specialize		NBTS_FUNCTION(_bt_specialize)
+#define btinsert			NBTS_FUNCTION(btinsert)
+#define _bt_dedup_pass		NBTS_FUNCTION(_bt_dedup_pass)
+#define _bt_doinsert		NBTS_FUNCTION(_bt_doinsert)
+#define _bt_search			NBTS_FUNCTION(_bt_search)
+#define _bt_binsrch_insert	NBTS_FUNCTION(_bt_binsrch_insert)
+#define _bt_compare			NBTS_FUNCTION(_bt_compare)
+#define _bt_mkscankey		NBTS_FUNCTION(_bt_mkscankey)
+#define _bt_checkkeys		NBTS_FUNCTION(_bt_checkkeys)
+#define _bt_truncate		NBTS_FUNCTION(_bt_truncate)
+#define _bt_keep_natts_fast	NBTS_FUNCTION(_bt_keep_natts_fast)
+
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void _bt_specialize(Relation rel);
+
+extern bool btinsert(Relation rel, Datum *values, bool *isnull,
+					 ItemPointer ht_ctid, Relation heapRel,
+					 IndexUniqueCheck checkUnique, bool indexUnchanged,
+					 struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
+						   Size newitemsz, bool bottomupdedup);
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool _bt_doinsert(Relation rel, IndexTuple itup,
+						 IndexUniqueCheck checkUnique, bool indexUnchanged,
+						 Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
+						  Buffer *bufP, int access);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate,
+									   AttrNumber highkeyprefix);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page,
+						 OffsetNumber offnum, AttrNumber *compareattr);
+
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
+extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+						  ScanDirection dir, bool *continuescan,
+						  bool requiredMatchedByPrecheck);
+extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright, BTScanInsert itup_key);
+extern int _bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright);
diff --git a/src/tools/pginclude/cpluspluscheck b/src/tools/pginclude/cpluspluscheck
index 4e09c4686b..e504a2f114 100755
--- a/src/tools/pginclude/cpluspluscheck
+++ b/src/tools/pginclude/cpluspluscheck
@@ -116,6 +116,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
diff --git a/src/tools/pginclude/headerscheck b/src/tools/pginclude/headerscheck
index 8dee1b5670..101888c806 100755
--- a/src/tools/pginclude/headerscheck
+++ b/src/tools/pginclude/headerscheck
@@ -111,6 +111,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
-- 
2.40.1

From 4499b7365da2436522e0b7a24cee209c6c70d324 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 12 Jan 2023 21:34:36 +0100
Subject: [PATCH v14 6/7] Add an attcacheoff-populating function

It populates attcacheoff-capable attributes with the correct offset,
and fills attributes whose offset is uncacheable with an 'uncacheable'
indicator value; as opposed to -1 which signals "unknown".

This allows users of the API to remove redundant cycles that try to
cache the offset of attributes - instead of O(N-attrs) operations, this
one only requires a O(1) check.
---
 src/backend/access/common/tupdesc.c | 111 ++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |   2 +
 2 files changed, 113 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index d119cfafb5..aa23fd18d6 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -847,3 +847,114 @@ TupleDescGetDefault(TupleDesc tupdesc, AttrNumber attnum)
 
 	return result;
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid offset value.
+ *
+ * Populates attcacheoff with a negative cache value when no offset
+ * can be calculated (due to e.g. variable length attributes).
+ * The negative value is a value relative to the last cacheable attribute
+ *   attcacheoff = -1 - (thisattno - cachedattno)
+ * so that the last attribute with cached offset can be found with
+ *   cachedattno = attcacheoff + 1 + thisattno
+ *   
+ * The value returned is the AttrNumber of the last (1-based) attribute that
+ * had its offset cached.
+ * 
+ * When the TupleDesc has 0 attributes, it returns 0.
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	currAttNo, lastCachedAttNo;
+
+	if (numberOfAttributes == 0)
+		return 0;
+
+	/* Non-negative value: this attribute is cached */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff >= 0)
+		return (AttrNumber) desc->natts;
+	/*
+	 * Attribute has been filled with relative offset to last cached value, but
+	 * it itself is unreachable.
+	 */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+		return (AttrNumber) (TupleDescAttr(desc, desc->natts - 1)->attcacheoff + 1 + desc->natts);
+
+	/* last attribute of the tupledesc may or may not support attcacheoff */
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	currAttNo = 1;
+	/*
+	 * Other code may have populated the value previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (currAttNo < numberOfAttributes &&
+		   TupleDescAttr(desc, currAttNo)->attcacheoff >= 0)
+		currAttNo++;
+
+	/*
+	 * Cache offset is undetermined. Start calculating offsets if possible.
+	 * 
+	 * When we exit this block, currAttNo will point at the first uncacheable
+	 * attribute, or past the end of the attribute array.
+	 */
+	if (currAttNo < numberOfAttributes &&
+		TupleDescAttr(desc, currAttNo)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, currAttNo - 1);
+		int32 off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (currAttNo < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, currAttNo);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+					{
+						att->attcacheoff = off;
+						currAttNo++;
+					}
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				currAttNo++;
+			}
+		}
+	}
+
+	Assert(currAttNo == numberOfAttributes || (
+		currAttNo < numberOfAttributes
+		&& TupleDescAttr(desc, (currAttNo - 1))->attcacheoff >= 0
+		&& TupleDescAttr(desc, currAttNo)->attcacheoff == -1
+	));
+	/*
+	 * No cacheable offsets left. Fill the rest with negative cache values,
+	 * but return the latest cached offset.
+	 */
+	lastCachedAttNo = currAttNo;
+
+	while (currAttNo < numberOfAttributes)
+	{
+		TupleDescAttr(desc, currAttNo)->attcacheoff = -1 - (currAttNo - lastCachedAttNo);
+		currAttNo++;
+	}
+
+	return lastCachedAttNo;
+}
\ No newline at end of file
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index d833d5f2e1..ee860f098e 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescFromLists(const List *names, const List *types, const
 
 extern Node *TupleDescGetDefault(TupleDesc tupdesc, AttrNumber attnum);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.40.1

From ffdd16f748b23bc0e107e5c765ea513dfe52d941 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Fri, 13 Jan 2023 15:42:41 +0100
Subject: [PATCH v14 7/7] btree: specialize attribute iteration for keys that
 can't use attcacheoff

The default code path is relatively slow at O(n^2), so with multiple
attributes we accept the increased _bt_compare startup cost in favour
of a lower CPU overhead for later attributes.

Note that this will only be used for indexes that use at least one
variable-length key attribute as non-final attribute. Indexes that have
only fixed-size attributes but that do have many nulls in their keys won't
see any benefit from this even if they theoretically would benefit.

However, it is not clear from an index's attributes alone that an index
will have many NULL attributes; the current code only looks at attribute
types and their sizes to determine whether to use the cacheable or
uncacheable paths.
---
 src/backend/access/nbtree/README        |   6 +-
 src/backend/access/nbtree/nbtree_spec.c |   3 +
 src/include/access/itup_attiter.h       | 199 ++++++++++++++++++++++++
 src/include/access/nbtree.h             |  11 +-
 src/include/access/nbtree_spec.h        |  48 +++++-
 5 files changed, 258 insertions(+), 9 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/backend/access/nbtree/README b/src/backend/access/nbtree/README
index 5cd408e2b4..e9daea356a 100644
--- a/src/backend/access/nbtree/README
+++ b/src/backend/access/nbtree/README
@@ -1119,14 +1119,12 @@ performance of those hot paths.
 
 Optimized code paths exist for the following cases, in order of preference:
  - indexes with only a single key attribute
+ - multi-column indexes that cannot pre-calculate the offsets of all key
+   attributes in the tuple data section
  - multi-column indexes that could benefit from the attcacheoff optimization
    NB: This is also the default path, and is comparatively slow for uncachable
    attribute offsets.
 
-Future work will optimize for multi-column indexes that don't benefit
-from the attcacheoff optimization by improving on the O(n^2) nature of
-index_getattr through storing attribute offsets.
-
 Notes About Data Representation
 -------------------------------
 
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
index 21635397ed..699197dfa7 100644
--- a/src/backend/access/nbtree/nbtree_spec.c
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -33,6 +33,9 @@ _bt_specialize(Relation rel)
 		case NBTS_CTX_CACHED:
 			_bt_specialize_cached(rel);
 			break;
+		case NBTS_CTX_UNCACHED:
+			_bt_specialize_uncached(rel);
+			break;
 		case NBTS_CTX_SINGLE_KEYATT:
 			_bt_specialize_single_keyatt(rel);
 			break;
diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..c8fb6954bc
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,199 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup_attiter.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+#include "varatt.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 1b88dca08f..7414d5cc8e 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1128,18 +1129,26 @@ typedef struct BTOptions
 
 typedef enum NBTS_CTX {
 	NBTS_CTX_SINGLE_KEYATT, 
+	NBTS_CTX_UNCACHED,
 	NBTS_CTX_CACHED, 
 	NBTS_CTX_DEFAULT, /* fallback */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	AttrNumber	nKeyAtts;
+
 	if (!PointerIsValid(irel))
 		return NBTS_CTX_DEFAULT;
 
-	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+	nKeyAtts = IndexRelationGetNumberOfKeyAttributes(irel);
+
+	if (nKeyAtts == 1)
 		return NBTS_CTX_SINGLE_KEYATT;
 
+	if (TupleDescAttr(irel->rd_att, nKeyAtts - 1)->attcacheoff < -1)
+		return NBTS_CTX_UNCACHED;
+
 	return NBTS_CTX_CACHED;
 }
 
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 8e476c300d..efed9824e7 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -45,6 +45,7 @@
  * Macros used in the nbtree specialization code.
  */
 #define NBTS_TYPE_SINGLE_KEYATT single_keyatt
+#define NBTS_TYPE_UNCACHED uncached
 #define NBTS_TYPE_CACHED cached
 #define NBTS_TYPE_DEFAULT default
 #define NBTS_CTX_NAME __nbts_ctx
@@ -53,8 +54,10 @@
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
 	(NBTS_CTX_NAME) == NBTS_CTX_SINGLE_KEYATT ? (NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT)) : ( \
-		(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
-			NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+		(NBTS_CTX_NAME) == NBTS_CTX_UNCACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED)) : ( \
+			(NBTS_CTX_NAME) == NBTS_CTX_CACHED ? (NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED)) : ( \
+				NBTS_MAKE_NAME(name, NBTS_TYPE_DEFAULT) \
+			) \
 		) \
 	) \
 )
@@ -69,8 +72,11 @@ do { \
 	Assert(PointerIsValid(rel)); \
 	if (unlikely((rel)->rd_indam->aminsert == btinsert_default)) \
 	{ \
-		nbts_prep_ctx(rel); \
-		_bt_specialize(rel); \
+		PopulateTupleDescCacheOffsets((rel)->rd_att); \
+		{ \
+			nbts_prep_ctx(rel); \
+			_bt_specialize(rel); \
+		} \
 	} \
 } while (false)
 
@@ -216,6 +222,40 @@ do { \
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Multiple key columns, but attcacheoff -optimization doesn't apply.
+ */
+#define NBTS_SPECIALIZING_UNCACHED
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef NBTS_SPECIALIZING_UNCACHED
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * All next uses of nbts_prep_ctx are in non-templated code, so here we make
  * sure we actually create the context.
-- 
2.40.1

From c739eba408fde5a87bf0f810e6e81544473b1490 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 12 Jan 2023 21:34:36 +0100
Subject: [PATCH v15 4/6] Add an attcacheoff-populating function

It populates attcacheoff-capable attributes with the correct offset,
and fills attributes whose offset is uncacheable with an 'uncacheable'
indicator value; as opposed to -1 which signals "unknown".

This allows users of the API to remove redundant cycles that try to
cache the offset of attributes - instead of O(N-attrs) operations, this
one only requires a O(1) check for repeat calls.
---
 src/backend/access/common/tupdesc.c | 111 ++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |   2 +
 2 files changed, 113 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index bc80caee11..3f3816b882 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -890,3 +890,114 @@ ResOwnerPrintTupleDesc(Datum res)
 	return psprintf("TupleDesc %p (%u,%d)",
 					tupdesc, tupdesc->tdtypeid, tupdesc->tdtypmod);
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid offset value.
+ *
+ * Populates attcacheoff with a negative cache value when no offset
+ * can be calculated (due to e.g. variable length attributes).
+ * The negative value is a value relative to the last cacheable attribute
+ *   attcacheoff = -1 - (thisattno - cachedattno)
+ * so that the last attribute with cached offset can be found with
+ *   cachedattno = attcacheoff + 1 + thisattno
+ *   
+ * The value returned is the AttrNumber of the last (1-based) attribute that
+ * had its offset cached.
+ * 
+ * When the TupleDesc has 0 attributes, it returns 0.
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	currAttNo, lastCachedAttNo;
+
+	if (numberOfAttributes == 0)
+		return 0;
+
+	/* Non-negative value: this attribute is cached */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff >= 0)
+		return (AttrNumber) desc->natts;
+	/*
+	 * Attribute has been filled with relative offset to last cached value, but
+	 * it itself is unreachable.
+	 */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+		return (AttrNumber) (TupleDescAttr(desc, desc->natts - 1)->attcacheoff + 1 + desc->natts);
+
+	/* last attribute of the tupledesc may or may not support attcacheoff */
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	currAttNo = 1;
+	/*
+	 * Other code may have populated the value previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (currAttNo < numberOfAttributes &&
+		   TupleDescAttr(desc, currAttNo)->attcacheoff >= 0)
+		currAttNo++;
+
+	/*
+	 * Cache offset is undetermined. Start calculating offsets if possible.
+	 * 
+	 * When we exit this block, currAttNo will point at the first uncacheable
+	 * attribute, or past the end of the attribute array.
+	 */
+	if (currAttNo < numberOfAttributes &&
+		TupleDescAttr(desc, currAttNo)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, currAttNo - 1);
+		int32 off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (currAttNo < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, currAttNo);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+					{
+						att->attcacheoff = off;
+						currAttNo++;
+					}
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				currAttNo++;
+			}
+		}
+	}
+
+	Assert(currAttNo == numberOfAttributes || (
+		currAttNo < numberOfAttributes
+		&& TupleDescAttr(desc, (currAttNo - 1))->attcacheoff >= 0
+		&& TupleDescAttr(desc, currAttNo)->attcacheoff == -1
+	));
+	/*
+	 * No cacheable offsets left. Fill the rest with negative cache values,
+	 * but return the latest cached offset.
+	 */
+	lastCachedAttNo = currAttNo;
+
+	while (currAttNo < numberOfAttributes)
+	{
+		TupleDescAttr(desc, currAttNo)->attcacheoff = -1 - (currAttNo - lastCachedAttNo);
+		currAttNo++;
+	}
+
+	return lastCachedAttNo;
+}
\ No newline at end of file
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index 3d767dde65..2ef4613719 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescFromLists(const List *names, const List *types, const
 
 extern Node *TupleDescGetDefault(TupleDesc tupdesc, AttrNumber attnum);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.42.1

From 3883b43328abceb1b10bc5d9463982ed6a381e5f Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 31 Jan 2024 02:06:41 +0100
Subject: [PATCH v15 5/6] btree: Optimize nbts_attiter for indexes with a
 single key attribute

This removes the index_getattr_nocache call path, which can have significant
overhead with branching, and replaces access to att->attcacheoff=0 with
constant 0.
---
 src/include/access/nbtree.h      | 46 ++++++++++++++++++++++++++++++--
 src/include/access/nbtree_spec.h | 43 +++++++++++++++++++++++++++++
 2 files changed, 87 insertions(+), 2 deletions(-)

diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index e1e80a8830..9579fed492 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1119,6 +1119,7 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
 #define NBTS_TYPE_CACHED CACHED
+#define NBTS_TYPE_SINGLE_KEYATT SINGLE_KEYATT
 
 /* Generate the specialized function headers */
 #define NBT_FILE "access/nbtree_specfuncs.h"
@@ -1130,20 +1131,61 @@ typedef struct BTOptions
 
 typedef enum NBTS_CTX {
 	NBTS_CTX_CACHED = 1, /* Equivalent to unspecialized code */
+	NBTS_CTX_SINGLE_KEYATT, /* Single key column index; cannot handle more */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	Assert(PointerIsValid(irel));
+
+	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+		return NBTS_CTX_SINGLE_KEYATT;
+
 	return NBTS_CTX_CACHED;
 }
 
+static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
+									bool *isNull)
+{
+	Datum	result;
+	if (IndexTupleHasNulls(tuple))
+	{
+		if (att_isnull(0, (bits8 *)(tuple) + sizeof(IndexTupleData)))
+		{
+			*isNull = true;
+			result = (Datum) 0;
+		}
+		else
+		{
+			*isNull = false;
+			result = fetchatt(TupleDescAttr(tupleDesc, 0),
+							  ((char *) tuple)
+							  + MAXALIGN(sizeof(IndexTupleData)
+							  + sizeof(IndexAttributeBitMapData)));
+		}
+	}
+	else
+	{
+		*isNull = false;
+		result = fetchatt(TupleDescAttr(tupleDesc, 0),
+						  ((char *) tuple)
+						  + MAXALIGN(sizeof(IndexTupleData)));
+	}
+
+	return result;
+}
+
 #define NBTS_CTX_NAME __nbts_ctx
 
 /* contextual specialization macros */
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME PG_USED_FOR_ASSERTS_ONLY = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
-	AssertMacro((NBTS_CTX_NAME) == NBTS_CTX_CACHED), \
-	NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+	(NBTS_CTX_NAME == NBTS_CTX_SINGLE_KEYATT) ? ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT) \
+	) : ( \
+		AssertMacro((NBTS_CTX_NAME) == NBTS_CTX_CACHED), \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+	) \
 )
 
 extern bool _btinsert_dispatch(Relation rel, Datum *values, bool *isnull,
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index c16659e603..4919f95e79 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -110,6 +110,49 @@
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 2: SINGLE_KEYATT
+ *
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path may never be used for indexes with multiple key
+ * columns, because it only considers the first column (plus any TIDs for tie
+ * breaking).
+ */
+#define NBTS_TYPE NBTS_TYPE_SINGLE_KEYATT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	_bt_getfirstatt(itup, tupDesc, &NBTS_MAKE_NAME(itup, isNull)) \
+)
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * We're done with templating, so restore or create the macros which can be
  * used in non-template sources.
-- 
2.42.1

From 2daab78101dabda6dee4cdf4bcbf38b73d07a6ed Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:57:21 +0100
Subject: [PATCH v15 1/6] btree specialization: Prepare code for
 specialization.

nbtree index keys are not all made the same, and a significant amount of
time is spent in code that exists only to deal with various key shapes. By
allowing the specialization of functions based on the key shape, we can
remove or reduce these causes of overhead.

This commit moves the various specializable functions into "_spec"
sourcefiles. Later commits will further modify these sources, mostly
mechanically, in a way that produces several optimized variants of the
functions for several distinct index key shapes.
---
 src/backend/access/nbtree/nbtdedup.c          |  298 +----
 src/backend/access/nbtree/nbtdedup_spec.c     |  315 +++++
 src/backend/access/nbtree/nbtinsert.c         |  553 +--------
 src/backend/access/nbtree/nbtinsert_spec.c    |  573 +++++++++
 src/backend/access/nbtree/nbtree.c            |   28 +-
 src/backend/access/nbtree/nbtree_spec.c       |   53 +
 src/backend/access/nbtree/nbtsearch.c         | 1074 +---------------
 src/backend/access/nbtree/nbtsearch_spec.c    | 1090 +++++++++++++++++
 src/backend/access/nbtree/nbtsort.c           |  261 +---
 src/backend/access/nbtree/nbtsort_spec.c      |  278 +++++
 src/backend/access/nbtree/nbtutils.c          |  791 +-----------
 src/backend/access/nbtree/nbtutils_spec.c     |  809 ++++++++++++
 src/backend/utils/sort/tuplesortvariants.c    |  151 +--
 .../utils/sort/tuplesortvariants_spec.c       |  172 +++
 src/include/access/nbtree.h                   |   27 +-
 src/include/access/nbtree_specfuncs.h         |   43 +
 src/tools/pginclude/cpluspluscheck            |    2 +
 src/tools/pginclude/headerscheck              |    2 +
 18 files changed, 3347 insertions(+), 3173 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.c
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.c
 create mode 100644 src/backend/access/nbtree/nbtree_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.c
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.c
 create mode 100644 src/backend/utils/sort/tuplesortvariants_spec.c
 create mode 100644 src/include/access/nbtree_specfuncs.h

diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 456d86b51c..c0410f1792 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,260 +22,13 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
-			   bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple and add it to our temp page (newpage).
-			 * Else add pending interval's base tuple to the temp page as-is.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place, when this page's newly allocated right sibling page
-				 * gets its first deduplication pass).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
+#include "nbtdedup_spec.c"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -752,55 +505,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
new file mode 100644
index 0000000000..056cf9908b
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -0,0 +1,315 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtdedup_spec.c
+ *	  Index shape-specialized functions for nbtdedup.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtdedup_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
+							 OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
+			   bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				minoff,
+				maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+				 _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple and add it to our temp page (newpage).
+			 * Else add pending interval's base tuple to the temp page as-is.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place, when this page's newly allocated right sibling page
+				 * gets its first deduplication pass).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+_bt_do_singleval(Relation rel, Page page, BTDedupState state,
+				 OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 709edd1c17..635ba48078 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,18 +30,10 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, Relation heaprel,
-								 BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
 static void _bt_stepright(Relation rel, Relation heaprel,
 						  BTInsertState insertstate, BTStack stack);
 static void _bt_insertonpg(Relation rel, Relation heaprel, BTScanInsert itup_key,
@@ -75,311 +67,7 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, heapRel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
-					   stack, itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
-
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
-					  BT_WRITE);
-}
+#include "nbtinsert_spec.c"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -772,245 +460,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 }
 
 
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
-					break;
-
-				_bt_stepright(rel, heapRel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, heapRel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
new file mode 100644
index 0000000000..b1f65ab1e6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -0,0 +1,573 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtinsert_spec.c
+ *	  Index shape-specialized functions for nbtinsert.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtinsert_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static BTStack _bt_search_insert(Relation rel, Relation heaprel,
+								 BTInsertState insertstate);
+static OffsetNumber _bt_findinsertloc(Relation rel,
+									  BTInsertState insertstate,
+									  bool checkingunique,
+									  bool indexUnchanged,
+									  BTStack stack,
+									  Relation heapRel);
+
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+_bt_doinsert(Relation rel, IndexTuple itup,
+			 IndexUniqueCheck checkUnique, bool indexUnchanged,
+			 Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = _bt_mkscankey(rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = _bt_search_insert(rel, heapRel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
+									   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
+					   stack, itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
+					  BT_WRITE);
+}
+
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+_bt_findinsertloc(Relation rel,
+				  BTInsertState insertstate,
+				  bool checkingunique,
+				  bool indexUnchanged,
+				  BTStack stack,
+				  Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
+					break;
+
+				_bt_stepright(rel, heapRel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, heapRel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	Assert(P_RIGHTMOST(opaque) ||
+		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
+
+	newitemoff = _bt_binsrch_insert(rel, insertstate);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = _bt_binsrch_insert(rel, insertstate);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 696d79c085..b29534a7f3 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,6 +87,7 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#include "nbtree_spec.c"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -182,33 +183,6 @@ btbuildempty(Relation index)
 	ReleaseBuffer(metabuf);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
new file mode 100644
index 0000000000..f6191303db
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -0,0 +1,53 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_spec.c
+ *	  Index shape-specialized functions for nbtree.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtree_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+_bt_specialize(Relation rel)
+{
+	rel->rd_indam->aminsert = btinsert;
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+btinsert(Relation rel, Datum *values, bool *isnull,
+		 ItemPointer ht_ctid, Relation heapRel,
+		 IndexUniqueCheck checkUnique,
+		 bool indexUnchanged,
+		 IndexInfo *indexInfo)
+{
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index 63ee9ba225..e46ed8f377 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -26,11 +26,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum, bool firstPage);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -47,6 +44,7 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#include "nbtsearch_spec.c"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -71,519 +69,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- *
- * heaprel must be provided by callers that pass access = BT_WRITE, since we
- * might need to allocate a new root page for caller -- see _bt_allocbuf.
- */
-BTStack
-_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
-		   int access)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-
-	/* heaprel must be set whenever _bt_allocbuf is reachable */
-	Assert(access == BT_READ || access == BT_WRITE);
-	Assert(access == BT_READ || heaprel != NULL);
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, heaprel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split is
- * completed.  'heaprel' and 'stack' are only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  Relation heaprel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	Assert(!forupdate || heaprel != NULL);
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		page = BufferGetPage(buf);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-			break;
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, heaprel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
-		{
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-			break;
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)
- *
- * On a leaf page, _bt_binsrch() returns the final result of the initial
- * positioning process that started with _bt_first's call to _bt_search.
- * We're returning a non-pivot tuple offset, so things are a little different.
- * It is possible that we'll return an offset that's either past the last
- * non-pivot slot, or (in the case of a backward scan) before the first slot.
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have at least one child).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-			high = mid;
-	}
-
-	/*
-	 * At this point we have high == low.
-	 *
-	 * On a leaf page we always return the first non-pivot tuple >= scan key
-	 * (resp. > scan key) for forward scan callers.  For backward scans, it's
-	 * always the _last_ non-pivot tuple < scan key (resp. <= scan key).
-	 */
-	if (P_ISLEAF(opaque))
-	{
-		/*
-		 * In the backward scan case we're supposed to locate the last
-		 * matching tuple on the leaf level -- not the first matching tuple
-		 * (the last tuple will be the first one returned by the scan).
-		 *
-		 * At this point we've located the first non-pivot tuple immediately
-		 * after the last matching tuple (which might just be maxoff + 1).
-		 * Compensate by stepping back.
-		 */
-		if (key->backward)
-			return OffsetNumberPrev(low);
-
-		return low;
-	}
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 *
-	 * _bt_compare() will seldom see any exactly-matching pivot tuples, since
-	 * a truncated -inf heap TID is usually enough to prevent it altogether.
-	 * Even omitted scan key entries are treated as > truncated attributes.
-	 *
-	 * However, during backward scans _bt_compare() interprets omitted scan
-	 * key attributes as == corresponding truncated -inf attributes instead.
-	 * This works just like < would work here.  Under this scheme, < strategy
-	 * backward scans will always directly descend to the correct leaf page.
-	 * In particular, they will never incur an "extra" leaf page access with a
-	 * scan key that happens to contain the same prefix of values as some
-	 * pivot tuple's untruncated prefix.  VACUUM relies on this guarantee when
-	 * it uses a leaf page high key to "re-find" a page undergoing deletion.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-		{
-			high = mid;
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
-
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
  *
@@ -651,207 +136,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-			return result;
-
-		scankey++;
-	}
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Forward scans have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.  Even attributes that were omitted from the
-		 * scan key are considered greater than -inf truncated attributes.
-		 * (See _bt_binsrch for an explanation of our backward scan behavior.)
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated -inf key
-		 * attributes.  The heap TID attribute is the last key attribute in
-		 * every index, of course, but other than that it isn't special.
-		 */
-		if (!key->backward && key->keysz == ntupatts && heapTid == NULL &&
-			key->heapkeyspace)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -1491,358 +775,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * _bt_first caller passes us an offnum returned by _bt_binsrch, which might
- * be an out of bounds offnum such as "maxoff + 1" in certain corner cases.
- * _bt_checkkeys will stop the scan as soon as an equality qual fails (when
- * its scan key was marked required), so _bt_first _must_ pass us an offnum
- * exactly at the beginning of where equal tuples are to be found.  When we're
- * passed an offnum past the end of the page, we might still manage to stop
- * the scan on this page by calling _bt_checkkeys against the high key.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum,
-			 bool firstPage)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-	bool		continuescanPrechecked;
-	bool		haveFirstMatch = false;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	/*
-	 * Prechecking the value of the continuescan flag for the last item on the
-	 * page (for backwards scan it will be the first item on a page).  If we
-	 * observe it to be true, then it should be true for all other items. This
-	 * allows us to do significant optimizations in the _bt_checkkeys()
-	 * function for all the items on the page.
-	 *
-	 * With the forward scan, we do this check for the last item on the page
-	 * instead of the high key.  It's relatively likely that the most
-	 * significant column in the high key will be different from the
-	 * corresponding value from the last item on the page.  So checking with
-	 * the last item on the page would give a more precise answer.
-	 *
-	 * We skip this for the first page in the scan to evade the possible
-	 * slowdown of the point queries.
-	 */
-	if (!firstPage && minoff < maxoff)
-	{
-		ItemId		iid;
-		IndexTuple	itup;
-
-		iid = PageGetItemId(page, ScanDirectionIsForward(dir) ? maxoff : minoff);
-		itup = (IndexTuple) PageGetItem(page, iid);
-
-		/*
-		 * Do the precheck.  Note that we pass the pointer to the
-		 * 'continuescanPrechecked' to the 'continuescan' argument. That will
-		 * set flag to true if all required keys are satisfied and false
-		 * otherwise.
-		 */
-		(void) _bt_checkkeys(scan, itup, indnatts, dir,
-							 &continuescanPrechecked, false, false);
-	}
-	else
-	{
-		continuescanPrechecked = false;
-	}
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-			Assert(!BTreeTupleIsPivot(itup));
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan,
-										 continuescanPrechecked,
-										 haveFirstMatch);
-
-			/*
-			 * If the result of prechecking required keys was true, then in
-			 * assert-enabled builds we also recheck that the _bt_checkkeys()
-			 * result is the same.
-			 */
-			Assert((!continuescanPrechecked && haveFirstMatch) ||
-				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
-												 &continuescan, false, false));
-			if (passes_quals)
-			{
-				/* tuple passes all scan key conditions */
-				haveFirstMatch = true;
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan, false, false);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-			Assert(!BTreeTupleIsPivot(itup));
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan,
-										 continuescanPrechecked,
-										 haveFirstMatch);
-
-			/*
-			 * If the result of prechecking required keys was true, then in
-			 * assert-enabled builds we also recheck that the _bt_checkkeys()
-			 * result is the same.
-			 */
-			Assert((!continuescanPrechecked && !haveFirstMatch) ||
-				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
-												 &continuescan, false, false));
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				haveFirstMatch = true;
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2051,13 +983,11 @@ static bool
 _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 {
 	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Relation	rel;
+	Relation	rel = scan->indexRelation;
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
 
-	rel = scan->indexRelation;
-
 	if (ScanDirectionIsForward(dir))
 	{
 		for (;;)
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
new file mode 100644
index 0000000000..a42aa4bb11
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -0,0 +1,1090 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsearch_spec.c
+ *	  Index shape-specialized functions for nbtsearch.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsearch_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
+							Buffer buf, bool forupdate, BTStack stack,
+							int access);
+static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
+						 OffsetNumber offnum, bool firstPage);
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ *
+ * heaprel must be provided by callers that pass access = BT_WRITE, since we
+ * might need to allocate a new root page for caller -- see _bt_allocbuf.
+ */
+BTStack
+_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
+		   int access)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+
+	/* heaprel must be set whenever _bt_allocbuf is reachable */
+	Assert(access == BT_READ || access == BT_WRITE);
+	Assert(access == BT_READ || heaprel != NULL);
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, heaprel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
+							  stack_in, page_access);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = _bt_binsrch(rel, key, *bufP);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split is
+ * completed.  'heaprel' and 'stack' are only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ */
+Buffer
+_bt_moveright(Relation rel,
+			  Relation heaprel,
+			  BTScanInsert key,
+			  Buffer buf,
+			  bool forupdate,
+			  BTStack stack,
+			  int access)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	Assert(!forupdate || heaprel != NULL);
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		page = BufferGetPage(buf);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+			break;
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, heaprel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
+		{
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+			break;
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)
+ *
+ * On a leaf page, _bt_binsrch() returns the final result of the initial
+ * positioning process that started with _bt_first's call to _bt_search.
+ * We're returning a non-pivot tuple offset, so things are a little different.
+ * It is possible that we'll return an offset that's either past the last
+ * non-pivot slot, or (in the case of a backward scan) before the first slot.
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+_bt_binsrch(Relation rel,
+			BTScanInsert key,
+			Buffer buf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have at least one child).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+			high = mid;
+	}
+
+	/*
+	 * At this point we have high == low.
+	 *
+	 * On a leaf page we always return the first non-pivot tuple >= scan key
+	 * (resp. > scan key) for forward scan callers.  For backward scans, it's
+	 * always the _last_ non-pivot tuple < scan key (resp. <= scan key).
+	 */
+	if (P_ISLEAF(opaque))
+	{
+		/*
+		 * In the backward scan case we're supposed to locate the last
+		 * matching tuple on the leaf level -- not the first matching tuple
+		 * (the last tuple will be the first one returned by the scan).
+		 *
+		 * At this point we've located the first non-pivot tuple immediately
+		 * after the last matching tuple (which might just be maxoff + 1).
+		 * Compensate by stepping back.
+		 */
+		if (key->backward)
+			return OffsetNumberPrev(low);
+
+		return low;
+	}
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 *
+	 * _bt_compare() will seldom see any exactly-matching pivot tuples, since
+	 * a truncated -inf heap TID is usually enough to prevent it altogether.
+	 * Even omitted scan key entries are treated as > truncated attributes.
+	 *
+	 * However, during backward scans _bt_compare() interprets omitted scan
+	 * key attributes as == corresponding truncated -inf attributes instead.
+	 * This works just like < would work here.  Under this scheme, < strategy
+	 * backward scans will always directly descend to the correct leaf page.
+	 * In particular, they will never incur an "extra" leaf page access with a
+	 * scan key that happens to contain the same prefix of values as some
+	 * pivot tuple's untruncated prefix.  VACUUM relies on this guarantee when
+	 * it uses a leaf page high key to "re-find" a page undergoing deletion.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+		{
+			high = mid;
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+										 ItemPointerGetBlockNumber(key->scantid),
+										 ItemPointerGetOffsetNumber(key->scantid),
+										 low, stricthigh,
+										 BufferGetBlockNumber(insertstate->buf),
+										 RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+_bt_compare(Relation rel,
+			BTScanInsert key,
+			Page page,
+			OffsetNumber offnum)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+	scankey = key->scankeys;
+	for (int i = 1; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+			return result;
+
+		scankey++;
+	}
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Forward scans have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.  Even attributes that were omitted from the
+		 * scan key are considered greater than -inf truncated attributes.
+		 * (See _bt_binsrch for an explanation of our backward scan behavior.)
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated -inf key
+		 * attributes.  The heap TID attribute is the last key attribute in
+		 * every index, of course, but other than that it isn't special.
+		 */
+		if (!key->backward && key->keysz == ntupatts && heapTid == NULL &&
+			key->heapkeyspace)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * _bt_first caller passes us an offnum returned by _bt_binsrch, which might
+ * be an out of bounds offnum such as "maxoff + 1" in certain corner cases.
+ * _bt_checkkeys will stop the scan as soon as an equality qual fails (when
+ * its scan key was marked required), so _bt_first _must_ pass us an offnum
+ * exactly at the beginning of where equal tuples are to be found.  When we're
+ * passed an offnum past the end of the page, we might still manage to stop
+ * the scan on this page by calling _bt_checkkeys against the high key.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum,
+			 bool firstPage)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+	bool		continuescanPrechecked;
+	bool		haveFirstMatch = false;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	/*
+	 * Prechecking the value of the continuescan flag for the last item on the
+	 * page (for backwards scan it will be the first item on a page).  If we
+	 * observe it to be true, then it should be true for all other items. This
+	 * allows us to do significant optimizations in the _bt_checkkeys()
+	 * function for all the items on the page.
+	 *
+	 * With the forward scan, we do this check for the last item on the page
+	 * instead of the high key.  It's relatively likely that the most
+	 * significant column in the high key will be different from the
+	 * corresponding value from the last item on the page.  So checking with
+	 * the last item on the page would give a more precise answer.
+	 *
+	 * We skip this for the first page in the scan to evade the possible
+	 * slowdown of the point queries.
+	 */
+	if (!firstPage && minoff < maxoff)
+	{
+		ItemId		iid;
+		IndexTuple	itup;
+
+		iid = PageGetItemId(page, ScanDirectionIsForward(dir) ? maxoff : minoff);
+		itup = (IndexTuple) PageGetItem(page, iid);
+
+		/*
+		 * Do the precheck.  Note that we pass the pointer to the
+		 * 'continuescanPrechecked' to the 'continuescan' argument. That will
+		 * set flag to true if all required keys are satisfied and false
+		 * otherwise.
+		 */
+		(void) _bt_checkkeys(scan, itup, indnatts, dir,
+							 &continuescanPrechecked, false, false);
+	}
+	else
+	{
+		continuescanPrechecked = false;
+	}
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+			Assert(!BTreeTupleIsPivot(itup));
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan,
+										 continuescanPrechecked,
+										 haveFirstMatch);
+
+			/*
+			 * If the result of prechecking required keys was true, then in
+			 * assert-enabled builds we also recheck that the _bt_checkkeys()
+			 * result is the same.
+			 */
+			Assert((!continuescanPrechecked && haveFirstMatch) ||
+				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
+												 &continuescan, false, false));
+			if (passes_quals)
+			{
+				/* tuple passes all scan key conditions */
+				haveFirstMatch = true;
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan, false, false);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+			Assert(!BTreeTupleIsPivot(itup));
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan,
+										 continuescanPrechecked,
+										 haveFirstMatch);
+
+			/*
+			 * If the result of prechecking required keys was true, then in
+			 * assert-enabled builds we also recheck that the _bt_checkkeys()
+			 * result is the same.
+			 */
+			Assert((!continuescanPrechecked && !haveFirstMatch) ||
+				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
+												 &continuescan, false, false));
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				haveFirstMatch = true;
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 2011196579..7455d099dd 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -279,8 +279,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -293,6 +291,7 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#include "nbtsort_spec.c"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -1178,264 +1177,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metapage, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			Assert(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-
-	/*
-	 * When we WAL-logged index pages, we must nonetheless fsync index files.
-	 * Since we're building outside shared buffers, a CHECKPOINT occurring
-	 * during the build has no way to flush the previously written data to
-	 * disk (indeed it won't know the index even exists).  A crash later on
-	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
-	 * earlier WAL entries. If we do not fsync those pages here, they might
-	 * still not be on disk when the crash occurs.
-	 */
-	if (wstate->btws_use_wal)
-		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
new file mode 100644
index 0000000000..044cb4f853
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -0,0 +1,278 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsort_spec.c
+ *	  Index shape-specialized functions for nbtsort.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsort_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static void _bt_load(BTWriteState *wstate,
+					 BTSpool *btspool, BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+				  BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			Assert(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+					   BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+										 sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize(state->btps_page) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
+										 itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+
+	/*
+	 * When we WAL-logged index pages, we must nonetheless fsync index files.
+	 * Since we're building outside shared buffers, a CHECKPOINT occurring
+	 * during the build has no way to flush the previously written data to
+	 * disk (indeed it won't know the index even exists).  A crash later on
+	 * would replay WAL from the checkpoint, therefore it wouldn't replay our
+	 * earlier WAL entries. If we do not fsync those pages here, they might
+	 * still not be on disk when the crash occurs.
+	 */
+	if (wstate->btws_use_wal)
+		smgrimmedsync(RelationGetSmgr(wstate->index), MAIN_FORKNUM);
+}
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 2e6fc14d7a..befd34b5df 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,122 +50,8 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
-
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;		/* usual case, required by btinsert */
-	key->backward = false;		/* usual case, required by btinsert */
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
+#include "nbtutils_spec.c"
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1347,401 +1233,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- * continuescanPrechecked: indicates that *continuescan flag is known to
- * 						   be true for the last item on the page
- * haveFirstMatch: indicates that we already have at least one match
- * 							  in the current page
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan,
-			  bool continuescanPrechecked, bool haveFirstMatch)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-		bool		requiredSameDir = false,
-					requiredOppositeDir = false;
-
-		/*
-		 * Check if the key is required for ordered scan in the same or
-		 * opposite direction.  Save as flag variables for future usage.
-		 */
-		if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsForward(dir)) ||
-			((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsBackward(dir)))
-			requiredSameDir = true;
-		else if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsBackward(dir)) ||
-				 ((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsForward(dir)))
-			requiredOppositeDir = true;
-
-		/*
-		 * If the caller told us the *continuescan flag is known to be true
-		 * for the last item on the page, then we know the keys required for
-		 * the current direction scan should be matched.  Otherwise, the
-		 * *continuescan flag would be set for the current item and
-		 * subsequently the last item on the page accordingly.
-		 *
-		 * If the key is required for the opposite direction scan, we can skip
-		 * the check if the caller tells us there was already at least one
-		 * matching item on the page. Also, we require the *continuescan flag
-		 * to be true for the last item on the page to know there are no
-		 * NULLs.
-		 *
-		 * Both cases above work except for the row keys, where NULLs could be
-		 * found in the middle of matching values.
-		 */
-		if ((requiredSameDir || (requiredOppositeDir && haveFirstMatch)) &&
-			!(key->sk_flags & SK_ROW_HEADER) && continuescanPrechecked)
-			continue;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if (requiredSameDir)
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		/*
-		 * Apply the key-checking function.  When the key is required for the
-		 * opposite direction scan, it must be already satisfied as soon as
-		 * there is already match on the page.  Except for the NULLs checking,
-		 * which have already done above.
-		 */
-		if (!(requiredOppositeDir && haveFirstMatch))
-		{
-			test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-									 datum, key->sk_argument);
-		}
-		else
-		{
-			test = true;
-			Assert(test == FunctionCall2Coll(&key->sk_func, key->sk_collation,
-											 datum, key->sk_argument));
-		}
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if (requiredSameDir)
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2225,286 +1716,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
new file mode 100644
index 0000000000..29a9ce3664
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -0,0 +1,809 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtutils_spec.c
+ *	  Index shape-specialized functions for nbtutils.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtutils_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static bool _bt_check_rowcompare(ScanKey skey,
+								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+								 ScanDirection dir, bool *continuescan);
+static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
+							 IndexTuple firstright, BTScanInsert itup_key);
+
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+_bt_mkscankey(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;		/* usual case, required by btinsert */
+	key->backward = false;		/* usual case, required by btinsert */
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+		BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ * continuescanPrechecked: indicates that *continuescan flag is known to
+ * 						   be true for the last item on the page
+ * haveFirstMatch: indicates that we already have at least one match
+ * 							  in the current page
+ */
+bool
+_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+			  ScanDirection dir, bool *continuescan,
+			  bool continuescanPrechecked, bool haveFirstMatch)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+		bool		requiredSameDir = false,
+					requiredOppositeDir = false;
+
+		/*
+		 * Check if the key is required for ordered scan in the same or
+		 * opposite direction.  Save as flag variables for future usage.
+		 */
+		if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsForward(dir)) ||
+			((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsBackward(dir)))
+			requiredSameDir = true;
+		else if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsBackward(dir)) ||
+				 ((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsForward(dir)))
+			requiredOppositeDir = true;
+
+		/*
+		 * If the caller told us the *continuescan flag is known to be true
+		 * for the last item on the page, then we know the keys required for
+		 * the current direction scan should be matched.  Otherwise, the
+		 * *continuescan flag would be set for the current item and
+		 * subsequently the last item on the page accordingly.
+		 *
+		 * If the key is required for the opposite direction scan, we can skip
+		 * the check if the caller tells us there was already at least one
+		 * matching item on the page. Also, we require the *continuescan flag
+		 * to be true for the last item on the page to know there are no
+		 * NULLs.
+		 *
+		 * Both cases above work except for the row keys, where NULLs could be
+		 * found in the middle of matching values.
+		 */
+		if ((requiredSameDir || (requiredOppositeDir && haveFirstMatch)) &&
+			!(key->sk_flags & SK_ROW_HEADER) && continuescanPrechecked)
+			continue;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
+									 continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if (requiredSameDir)
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		/*
+		 * Apply the key-checking function.  When the key is required for the
+		 * opposite direction scan, it must be already satisfied as soon as
+		 * there is already match on the page.  Except for the NULLs checking,
+		 * which have already done above.
+		 */
+		if (!(requiredOppositeDir && haveFirstMatch))
+		{
+			test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+									 datum, key->sk_argument);
+		}
+		else
+		{
+			test = true;
+			Assert(test == FunctionCall2Coll(&key->sk_func, key->sk_collation,
+											 datum, key->sk_argument));
+		}
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if (requiredSameDir)
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
+					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+			/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			 BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			   BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index 08f9f16262..6da7d7fd58 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -64,10 +64,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int tuplen);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
-static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
-											Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static int	comparetup_index_hash_tiebreak(const SortTuple *a, const SortTuple *b,
@@ -163,6 +159,7 @@ typedef struct BrinSortTuple
 /* Size of the BrinSortTuple, given length of the BrinTuple. */
 #define BRINSORTTUPLE_SIZE(len)		(offsetof(BrinSortTuple, tuple) + (len))
 
+#include "tuplesortvariants_spec.c"
 
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
@@ -1410,152 +1407,6 @@ removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
 	}
 }
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	SortSupport sortKey = base->sortKeys;
-	int32		compare;
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	return comparetup_index_btree_tiebreak(a, b, state);
-}
-
-static int
-comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
-								Tuplesortstate *state)
-{
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
-	SortSupport sortKey = base->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = base->nKeys;
-	tupDes = RelationGetDescr(arg->index.indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(arg->index.indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(arg->index.heapRel,
-									RelationGetRelationName(arg->index.indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
new file mode 100644
index 0000000000..76cabb207e
--- /dev/null
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -0,0 +1,172 @@
+/*-------------------------------------------------------------------------
+ *
+ * tuplesortvariants_spec.c
+ *	  Index shape-specialized functions for tuplesortvariants.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/tuplesortvariants_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+								   Tuplesortstate *state);
+static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
+											Tuplesortstate *state);
+
+static int
+comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+					   Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	SortSupport sortKey = base->sortKeys;
+	int32		compare;
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	return comparetup_index_btree_tiebreak(a, b, state);
+}
+
+static int
+comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
+								Tuplesortstate *state)
+{	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
+	SortSupport sortKey = base->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	Datum		datum1,
+				datum2;
+	bool		isnull1,
+				isnull2;
+
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = base->nKeys;
+	tupDes = RelationGetDescr(arg->index.indexRel);
+
+	if (sortKey->abbrev_converter)
+	{
+		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
+
+		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
+												datum2, isnull2,
+												sortKey);
+		if (compare != 0)
+			return compare;
+	}
+
+	/* they are equal, so we only need to examine one null flag */
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	sortKey++;
+	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	{
+		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+
+		compare = ApplySortComparator(datum1, isnull1,
+									  datum2, isnull2,
+									  sortKey);
+		if (compare != 0)
+			return compare;		/* done when we find unequal attributes */
+
+		/* they are equal, so we only need to examine one null flag */
+		if (isnull1)
+			equal_hasnull = true;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(arg->index.indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(arg->index.heapRel,
+									   RelationGetRelationName(arg->index.indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 6eb162052e..63e245dcbc 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1118,15 +1118,12 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+#include "access/nbtree_specfuncs.h"
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1157,8 +1154,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
-						   Size newitemsz, bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1174,9 +1169,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Relation heaprel, Buffer lbuf,
 							 BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, Relation heaprel, BTStack stack,
@@ -1227,13 +1219,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
-						  Buffer *bufP, int access);
-extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
-							Buffer buf, bool forupdate, BTStack stack,
-							int access);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost);
@@ -1241,7 +1226,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost);
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1249,9 +1233,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan,
-						  bool requiredMatchedByPrecheck, bool haveFirstMatch);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1264,10 +1245,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
new file mode 100644
index 0000000000..d2ca62cb3b
--- /dev/null
+++ b/src/include/access/nbtree_specfuncs.h
@@ -0,0 +1,43 @@
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void _bt_specialize(Relation rel);
+
+extern bool btinsert(Relation rel, Datum *values, bool *isnull,
+					 ItemPointer ht_ctid, Relation heapRel,
+					 IndexUniqueCheck checkUnique, bool indexUnchanged,
+					 struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
+						   Size newitemsz, bool bottomupdedup);
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool _bt_doinsert(Relation rel, IndexTuple itup,
+						 IndexUniqueCheck checkUnique, bool indexUnchanged,
+						 Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
+						  Buffer *bufP, int access);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
+
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
+extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+						  ScanDirection dir, bool *continuescan,
+						  bool requiredMatchedByPrecheck, bool haveFirstMatch);
+extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright, BTScanInsert itup_key);
+extern int _bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright);
diff --git a/src/tools/pginclude/cpluspluscheck b/src/tools/pginclude/cpluspluscheck
index 7edfc44b49..d822927976 100755
--- a/src/tools/pginclude/cpluspluscheck
+++ b/src/tools/pginclude/cpluspluscheck
@@ -116,6 +116,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
diff --git a/src/tools/pginclude/headerscheck b/src/tools/pginclude/headerscheck
index 84b892b5c5..fd334ed70e 100755
--- a/src/tools/pginclude/headerscheck
+++ b/src/tools/pginclude/headerscheck
@@ -111,6 +111,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
-- 
2.42.1

From 20b030628d3eacb24d451bd0856378308d1e67ec Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 31 Jan 2024 02:21:00 +0100
Subject: [PATCH v15 6/6] btree: Specialize various performance-sensitive
 functions on btree key shape.

nbtree keys are not all made the same, and a significant amount of time is
spent in code that exists only to deal with various key shapes. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, and splits the code that can
benefit from attribute offset optimizations into separate files. This does
NOT yet update the code itself - it just makes the code compile cleanly.
The performance should be comparable if not the same.
---
 src/include/access/itup_attiter.h | 199 ++++++++++++++++++++++++++++++
 src/include/access/nbtree.h       |  20 ++-
 src/include/access/nbtree_spec.h  |  36 ++++++
 3 files changed, 252 insertions(+), 3 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..abf52761e7
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,199 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup_attiter.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+#include "varatt.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 9579fed492..58d8a0fdc3 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1120,6 +1121,7 @@ typedef struct BTOptions
 
 #define NBTS_TYPE_CACHED CACHED
 #define NBTS_TYPE_SINGLE_KEYATT SINGLE_KEYATT
+#define NBTS_TYPE_UNCACHED UNCACHED
 
 /* Generate the specialized function headers */
 #define NBT_FILE "access/nbtree_specfuncs.h"
@@ -1132,15 +1134,23 @@ typedef struct BTOptions
 typedef enum NBTS_CTX {
 	NBTS_CTX_CACHED = 1, /* Equivalent to unspecialized code */
 	NBTS_CTX_SINGLE_KEYATT, /* Single key column index; cannot handle more */
+	NBTS_CTX_UNCACHED, /* Last key attribute can't use attcachoff */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	AttrNumber	nKeyAtts;
+
 	Assert(PointerIsValid(irel));
 
-	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+	nKeyAtts = IndexRelationGetNumberOfKeyAttributes(irel);
+
+	if (nKeyAtts == 1)
 		return NBTS_CTX_SINGLE_KEYATT;
 
+	if (TupleDescAttr(irel->rd_att, nKeyAtts - 1)->attcacheoff < -1)
+		return NBTS_CTX_UNCACHED;
+
 	return NBTS_CTX_CACHED;
 }
 
@@ -1183,8 +1193,12 @@ static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
 	(NBTS_CTX_NAME == NBTS_CTX_SINGLE_KEYATT) ? ( \
 		NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT) \
 	) : ( \
-		AssertMacro((NBTS_CTX_NAME) == NBTS_CTX_CACHED), \
-		NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+		((NBTS_CTX_NAME) == NBTS_CTX_UNCACHED) ? ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED) \
+		) : ( \
+			AssertMacro((NBTS_CTX_NAME) == NBTS_CTX_CACHED), \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+		) \
 	) \
 )
 
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 4919f95e79..2f3f615ea4 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -153,6 +153,42 @@
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 3: UNCACHED
+ *
+ * Multiple key columns, but attcacheoff -optimization doesn't apply because
+ * some intermediate or prefixing key attributes that don't have a fixed size
+ * at the type level (i.e. their attlen < 0).
+ */
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * We're done with templating, so restore or create the macros which can be
  * used in non-template sources.
-- 
2.42.1

From 78f3858ca56a3b50fd5fd806a0431e7ac1d0fda7 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 31 Jan 2024 01:40:40 +0100
Subject: [PATCH v15 3/6] btree: Introduce attribute iterator specialization
 infrastructure

This allows the specialization framework to utilize different optimized
attribute iteration methods based on key shape, e.g. one that utilizes
attcacheoff; one that doens't need to calculate offset because of the
use of only one key attribute, or one that incrementally finds next
offsets for each attribute in the tuple.

Even though not all nbt*_spec functions have been updated, these functions
can now directly call (and potentially inline, and optimize for) the
specialized functions they call, instead of having to determine the right
specialization locally based on the (potentially locally unavailable) index
relation, making the specialization of those functions still worth
specializing/duplicating.
---
 src/backend/access/nbtree/nbtsearch_spec.c    | 17 +++--
 src/backend/access/nbtree/nbtsort_spec.c      | 24 +++----
 src/backend/access/nbtree/nbtutils_spec.c     | 62 ++++++++++++-------
 .../utils/sort/tuplesortvariants_spec.c       | 53 +++++++++-------
 src/include/access/nbtree_spec.h              | 49 +++++++++++++++
 5 files changed, 141 insertions(+), 64 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index d65765ca23..cf5e559c28 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -581,6 +581,7 @@ _bt_compare(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -611,24 +612,28 @@ _bt_compare(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+
 	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index 3ad997c332..c22729dc36 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -34,8 +34,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -57,7 +56,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -90,21 +89,24 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 			else if (itup != NULL)
 			{
 				int32		compare = 0;
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index 38e27f1757..fad68250de 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -56,7 +56,7 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -87,7 +87,10 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 		BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -98,27 +101,30 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -712,6 +718,8 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -723,20 +731,22 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -744,6 +754,7 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -784,24 +795,27 @@ _bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 705da09329..cf262eee2d 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -66,47 +66,54 @@ comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
 	bool		equal_hasnull = false;
 	int			nkey;
 	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
 
 	tuple1 = (IndexTuple) a->tuple;
 	tuple2 = (IndexTuple) b->tuple;
 	keysz = base->nKeys;
 	tupDes = RelationGetDescr(arg->index.indexRel);
 
-	if (sortKey->abbrev_converter)
+	if (!sortKey->abbrev_converter)
 	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
+		nkey = 2;
+		sortKey++;
+	}
+	else
+	{
+		nkey = 1;
 	}
 
 	/* they are equal, so we only need to examine one null flag */
 	if (a->isnull1)
 		equal_hasnull = true;
 
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
 	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+		Datum	datum1,
+				datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		else
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
 
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
 		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
+			return compare;
 
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
+		if (nbts_attiter_curattisnull(tuple1))
 			equal_hasnull = true;
+
+		sortKey++;
 	}
 
 	/*
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 731f2fb946..c16659e603 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -20,6 +20,33 @@
  * Specialized files define their functions like usual, with an additional
  * requirement that they #define their function name at the top, with
  * #define funcname NBTS_FUNCTION(funcname).
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ * - nbts_context(irel)
+ *   Constructs a context that is used to call specialized functions.
+ *   Note that this is unneeded in paths that are inaccessible to unspecialized
+ *   code paths (i.e. code included through nbtree_spec.h), because that
+ *   always calls the optimized functions directly.
  */
 
 #if defined(NBT_FILE)
@@ -57,9 +84,31 @@
  */
 #define NBTS_TYPE NBTS_TYPE_CACHED
 
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) do {} while (false)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
 #include NBT_SPECIALIZE_FILE
 
 #undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
 
 /*
  * We're done with templating, so restore or create the macros which can be
-- 
2.42.1

From 011f5d88edb9ef95428a625295206a8f16328928 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 31 Jan 2024 01:27:06 +0100
Subject: [PATCH v15 2/6] btree: Introduce basic specialization

This introduces the basic infrastructure for specialization, and updates
call sites of the specialized functions to use the new infrastructure.

Note that actual meaningful code behaviour changes will happen in a later
commit, this only builds the scaffolds.

Specialized functions are written in _spec files, and their names are
defined as macros that produce either a specialized name token (when in a
specialized context), or an expression (which utilizes an in-scope
nbts_prep_ctx-prepared context) that evaluates to a function pointer which
points to the indicated function's variant which is most optimized for that
context's index key shape.
---
 contrib/amcheck/verify_nbtree.c               |  7 ++
 src/backend/access/nbtree/nbtdedup.c          |  4 +-
 src/backend/access/nbtree/nbtdedup_spec.c     |  2 +
 src/backend/access/nbtree/nbtinsert.c         |  6 +-
 src/backend/access/nbtree/nbtinsert_spec.c    |  3 +
 src/backend/access/nbtree/nbtpage.c           |  1 +
 src/backend/access/nbtree/nbtree.c            | 30 ++++++-
 src/backend/access/nbtree/nbtsearch.c         |  6 +-
 src/backend/access/nbtree/nbtsearch_spec.c    |  4 +
 src/backend/access/nbtree/nbtsort.c           |  5 +-
 src/backend/access/nbtree/nbtsort_spec.c      |  2 +
 src/backend/access/nbtree/nbtsplitloc.c       |  3 +
 src/backend/access/nbtree/nbtutils.c          |  3 +-
 src/backend/access/nbtree/nbtutils_spec.c     |  3 +
 src/backend/utils/sort/tuplesortvariants.c    |  6 +-
 .../utils/sort/tuplesortvariants_spec.c       |  3 +
 src/include/access/nbtree.h                   | 45 +++++++++-
 src/include/access/nbtree_spec.h              | 86 +++++++++++++++++++
 src/include/access/nbtree_specfuncs.h         | 16 ++++
 19 files changed, 226 insertions(+), 9 deletions(-)
 create mode 100644 src/include/access/nbtree_spec.h

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 91caa53dd8..636ec1199e 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -1369,6 +1369,7 @@ bt_target_page_check(BtreeCheckState *state)
 	OffsetNumber offset;
 	OffsetNumber max;
 	BTPageOpaque topaque;
+	nbts_prep_ctx(state->rel);
 
 	/* last visible entry info for checking indexes with unique constraint */
 	int			lVis_i = -1;	/* the position of last visible item for
@@ -3066,6 +3067,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 	BTStack		stack;
 	Buffer		lbuf;
 	bool		exists;
+	nbts_prep_ctx(state->rel);
 
 	key = _bt_mkscankey(state->rel, itup);
 	Assert(key->heapkeyspace && key->scantid != NULL);
@@ -3164,6 +3166,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	nbts_prep_ctx(state->rel);
 
 	Assert(!key->nextkey && key->backward);
 
@@ -3226,6 +3229,7 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	nbts_prep_ctx(state->rel);
 
 	Assert(!key->nextkey && key->backward);
 
@@ -3249,6 +3253,7 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	nbts_prep_ctx(state->rel);
 
 	Assert(!key->nextkey && key->backward);
 
@@ -3287,6 +3292,7 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	nbts_prep_ctx(state->rel);
 
 	Assert(!key->nextkey && key->backward);
 
@@ -3522,6 +3528,7 @@ static inline BTScanInsert
 bt_mkscankey_pivotsearch(Relation rel, IndexTuple itup)
 {
 	BTScanInsert skey;
+	nbts_prep_ctx(rel);
 
 	skey = _bt_mkscankey(rel, itup);
 	skey->backward = true;
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index c0410f1792..74e5dc0905 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -28,7 +28,8 @@ static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-#include "nbtdedup_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtdedup_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -69,6 +70,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 	TM_IndexDeleteOp delstate;
 	bool		neverdedup;
 	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	nbts_prep_ctx(rel);
 
 	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
 	newitemsz += sizeof(ItemIdData);
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
index 056cf9908b..6db340dce6 100644
--- a/src/backend/access/nbtree/nbtdedup_spec.c
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -15,6 +15,8 @@
  *-------------------------------------------------------------------------
  */
 
+#define _bt_do_singleval NBTS_FUNCTION(_bt_do_singleval)
+
 static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
 							 OffsetNumber minoff, IndexTuple newitem);
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 635ba48078..9665588443 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -67,7 +67,8 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-#include "nbtinsert_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtinsert_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -111,6 +112,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	bool		inposting = false;
 	bool		prevalldead = true;
 	int			curposti = 0;
+	nbts_prep_ctx(rel);
 
 	/* Assume unique until we find a duplicate */
 	*is_unique = true;
@@ -943,6 +945,7 @@ _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
 	bool		newitemonleft,
 				isleaf,
 				isrightmost;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * origpage is the original page to be split.  leftpage is a temporary
@@ -2143,6 +2146,7 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 	BTScanInsert itup_key = insertstate->itup_key;
 	Page		page = BufferGetPage(buffer);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
+	nbts_prep_ctx(rel);
 
 	Assert(P_ISLEAF(opaque));
 	Assert(simpleonly || itup_key->heapkeyspace);
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
index b1f65ab1e6..64f62b41b8 100644
--- a/src/backend/access/nbtree/nbtinsert_spec.c
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -16,6 +16,9 @@
  *-------------------------------------------------------------------------
  */
 
+#define _bt_search_insert NBTS_FUNCTION(_bt_search_insert)
+#define _bt_findinsertloc NBTS_FUNCTION(_bt_findinsertloc)
+
 static BTStack _bt_search_insert(Relation rel, Relation heaprel,
 								 BTInsertState insertstate);
 static OffsetNumber _bt_findinsertloc(Relation rel,
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 567bade9f4..a2be1c2da3 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1810,6 +1810,7 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 	bool		rightsib_empty;
 	Page		page;
 	BTPageOpaque opaque;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Save original leafbuf block number from caller.  Only deleted blocks
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index b29534a7f3..68048d9ef3 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -87,7 +87,8 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
-#include "nbtree_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtree_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -123,7 +124,7 @@ bthandler(PG_FUNCTION_ARGS)
 
 	amroutine->ambuild = btbuild;
 	amroutine->ambuildempty = btbuildempty;
-	amroutine->aminsert = btinsert;
+	amroutine->aminsert = _btinsert_dispatch;
 	amroutine->aminsertcleanup = NULL;
 	amroutine->ambulkdelete = btbulkdelete;
 	amroutine->amvacuumcleanup = btvacuumcleanup;
@@ -158,6 +159,8 @@ btbuildempty(Relation index)
 	Buffer		metabuf;
 	Page		metapage;
 
+	nbt_opt_specialize(index);
+
 	/*
 	 * Initialize the metapage.
 	 *
@@ -183,6 +186,27 @@ btbuildempty(Relation index)
 	ReleaseBuffer(metabuf);
 }
 
+/*
+ *	_btinsert_dispatch() -- dispatcher for specialized btinsert functions.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+_btinsert_dispatch(Relation rel, Datum *values, bool *isnull,
+				   ItemPointer ht_ctid, Relation heapRel,
+				   IndexUniqueCheck checkUnique,
+				   bool indexUnchanged,
+				   IndexInfo *indexInfo)
+{
+	nbts_prep_ctx(rel);
+
+	_bt_specialize(rel);
+
+	return btinsert(rel, values, isnull, ht_ctid, heapRel, checkUnique,
+					indexUnchanged, indexInfo);
+}
+
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
@@ -323,6 +347,7 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 {
 	IndexScanDesc scan;
 	BTScanOpaque so;
+	nbt_opt_specialize(rel);
 
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
@@ -767,6 +792,7 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 {
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
+	nbt_opt_specialize(rel);
 
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index e46ed8f377..2adb73aa0d 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -44,7 +44,8 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
-#include "nbtsearch_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtsearch_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -174,6 +175,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	nbts_prep_ctx(rel);
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -987,6 +989,7 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
+	nbts_prep_ctx(rel);
 
 	if (ScanDirectionIsForward(dir))
 	{
@@ -1377,6 +1380,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	BTPageOpaque opaque;
 	OffsetNumber start;
 	BTScanPosItem *currItem;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Scan down to the leftmost or rightmost leaf page.  This is a simplified
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index a42aa4bb11..d65765ca23 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -16,6 +16,10 @@
  *-------------------------------------------------------------------------
  */
 
+#define _bt_binsrch		NBTS_FUNCTION(_bt_binsrch)
+#define _bt_moveright	NBTS_FUNCTION(_bt_moveright)
+#define _bt_readpage	NBTS_FUNCTION(_bt_readpage)
+
 static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
 static Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
 							Buffer buf, bool forupdate, BTStack stack,
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index 7455d099dd..0bd0c5ffcf 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -291,7 +291,8 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
-#include "nbtsort_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtsort_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -543,6 +544,7 @@ static void
 _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 {
 	BTWriteState wstate;
+	nbts_prep_ctx(btspool->index);
 
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
@@ -845,6 +847,7 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 	Size		pgspc;
 	Size		itupsz;
 	bool		isleaf;
+	nbts_prep_ctx(wstate->index);
 
 	/*
 	 * This is a handy place to check for cancel interrupts during the btree
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index 044cb4f853..3ad997c332 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -16,6 +16,8 @@
  *-------------------------------------------------------------------------
  */
 
+#define _bt_load NBTS_FUNCTION(_bt_load)
+
 static void _bt_load(BTWriteState *wstate,
 					 BTSpool *btspool, BTSpool *btspool2);
 
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index d0b1d82578..fb8b75ee0a 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -639,6 +639,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	ItemId		itemid;
 	IndexTuple	tup;
 	int			keepnatts;
+	nbts_prep_ctx(state->rel);
 
 	Assert(state->is_leaf && !state->is_rightmost);
 
@@ -945,6 +946,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 			   *rightinterval;
 	int			perfectpenalty;
 	int			indnkeyatts = IndexRelationGetNumberOfKeyAttributes(state->rel);
+	nbts_prep_ctx(state->rel);
 
 	/* Assume that alternative strategy won't be used for now */
 	*strategy = SPLIT_DEFAULT;
@@ -1137,6 +1139,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 {
 	IndexTuple	lastleft;
 	IndexTuple	firstright;
+	nbts_prep_ctx(state->rel);
 
 	if (!state->is_leaf)
 	{
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index befd34b5df..22b9f04b0e 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -51,7 +51,8 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
 
-#include "nbtutils_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtutils_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * free a retracement stack made by _bt_search.
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index 29a9ce3664..38e27f1757 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -16,6 +16,9 @@
  *-------------------------------------------------------------------------
  */
 
+#define _bt_check_rowcompare	NBTS_FUNCTION(_bt_check_rowcompare)
+#define _bt_keep_natts			NBTS_FUNCTION(_bt_keep_natts)
+
 static bool _bt_check_rowcompare(ScanKey skey,
 								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
 								 ScanDirection dir, bool *continuescan);
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index 6da7d7fd58..dfd3c31d47 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -159,7 +159,8 @@ typedef struct BrinSortTuple
 /* Size of the BrinSortTuple, given length of the BrinTuple. */
 #define BRINSORTTUPLE_SIZE(len)		(offsetof(BrinSortTuple, tuple) + (len))
 
-#include "tuplesortvariants_spec.c"
+#define NBT_FILE "../../backend/utils/sort/tuplesortvariants_spec.c"
+#include "access/nbtree_spec.h"
 
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
@@ -249,6 +250,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 	MemoryContext oldcontext;
 	TuplesortClusterArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	Assert(indexRel->rd_rel->relam == BTREE_AM_OID);
 
@@ -361,6 +363,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	TuplesortIndexBTreeArg *arg;
 	MemoryContext oldcontext;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -496,6 +499,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 	MemoryContext oldcontext;
 	TuplesortIndexBTreeArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 76cabb207e..705da09329 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -16,6 +16,9 @@
  *-------------------------------------------------------------------------
  */
 
+#define comparetup_index_btree NBTS_FUNCTION(comparetup_index_btree)
+#define comparetup_index_btree_tiebreak NBTS_FUNCTION(comparetup_index_btree_tiebreak)
+
 static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 								   Tuplesortstate *state);
 static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 63e245dcbc..e1e80a8830 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1118,7 +1118,50 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
-#include "access/nbtree_specfuncs.h"
+#define NBTS_TYPE_CACHED CACHED
+
+/* Generate the specialized function headers */
+#define NBT_FILE "access/nbtree_specfuncs.h"
+#include "access/nbtree_spec.h"
+
+/*
+ * Further specialization helpers and definitions
+ */
+
+typedef enum NBTS_CTX {
+	NBTS_CTX_CACHED = 1, /* Equivalent to unspecialized code */
+} NBTS_CTX;
+
+static inline NBTS_CTX _nbt_spec_context(Relation irel)
+{
+	return NBTS_CTX_CACHED;
+}
+
+#define NBTS_CTX_NAME __nbts_ctx
+
+/* contextual specialization macros */
+#define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME PG_USED_FOR_ASSERTS_ONLY = _nbt_spec_context(rel)
+#define NBTS_SPECIALIZE_NAME(name) ( \
+	AssertMacro((NBTS_CTX_NAME) == NBTS_CTX_CACHED), \
+	NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+)
+
+extern bool _btinsert_dispatch(Relation rel, Datum *values, bool *isnull,
+							   ItemPointer ht_ctid, Relation heapRel,
+							   IndexUniqueCheck checkUnique,
+							   bool indexUnchanged,
+							   struct IndexInfo *indexInfo);
+
+static inline
+void nbt_opt_specialize(Relation rel)
+{
+	Assert(PointerIsValid(rel));
+	if (unlikely((rel)->rd_indam->aminsert == _btinsert_dispatch))
+	{
+		nbts_prep_ctx(rel);
+		_bt_specialize(rel);
+	}
+}
 
 /*
  * external entry points for btree, in nbtree.c
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
new file mode 100644
index 0000000000..731f2fb946
--- /dev/null
+++ b/src/include/access/nbtree_spec.h
@@ -0,0 +1,86 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those. The file
+ * that's marked for specialization is either
+ * - NBTS_HEADER, a quoted header inclusion path; or
+ * - NBTS_FILE, the include path of the to-be-specialized code relative to
+ *		the access/nbtree_spec.h file.
+ *
+ * Specialized files define their functions like usual, with an additional
+ * requirement that they #define their function name at the top, with
+ * #define funcname NBTS_FUNCTION(funcname).
+ */
+
+#if defined(NBT_FILE)
+#define NBT_SPECIALIZE_FILE NBT_FILE
+#else
+#error "No specializable file defined"
+#endif
+
+/* how do we make names? */
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+
+/*
+ * Protections against multiple inclusions - the definition of this macro is
+ * different for files included by this file as template, versus those that
+ * include this file for the definitions, so we redefine these macros at top and
+ * bottom.
+ */
+#ifdef NBTS_FUNCTION
+#undef NBTS_FUNCTION
+#endif
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+/* In a specialized file, specialization contexts are meaningless */
+#ifdef nbts_prep_ctx
+#undef nbts_prep_ctx
+#endif
+
+/*
+ * Specialization 1: CACHED
+ *
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+
+/*
+ * We're done with templating, so restore or create the macros which can be
+ * used in non-template sources.
+ */
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+/*
+ * from here on all NBTS_FUNCTIONs are from specialized function names that
+ * are being called. Change the result of those macros from a direct call
+ * call to a conditional call to the right place, depending on the correct
+ * context.
+ */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) NBTS_SPECIALIZE_NAME(name)
+
+/* cleanup unwanted definitions from file inclusion */
+#undef NBT_SPECIALIZE_FILE
+#ifdef NBT_HEADERS
+#undef NBT_HEADERS
+#endif
+#ifdef NBT_FILE
+#undef NBT_FILE
+#endif
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
index d2ca62cb3b..00b718324e 100644
--- a/src/include/access/nbtree_specfuncs.h
+++ b/src/include/access/nbtree_specfuncs.h
@@ -1,3 +1,19 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+#define _bt_specialize		NBTS_FUNCTION(_bt_specialize)
+#define btinsert			NBTS_FUNCTION(btinsert)
+#define _bt_dedup_pass		NBTS_FUNCTION(_bt_dedup_pass)
+#define _bt_doinsert		NBTS_FUNCTION(_bt_doinsert)
+#define _bt_search			NBTS_FUNCTION(_bt_search)
+#define _bt_binsrch_insert	NBTS_FUNCTION(_bt_binsrch_insert)
+#define _bt_compare			NBTS_FUNCTION(_bt_compare)
+#define _bt_mkscankey		NBTS_FUNCTION(_bt_mkscankey)
+#define _bt_checkkeys		NBTS_FUNCTION(_bt_checkkeys)
+#define _bt_truncate		NBTS_FUNCTION(_bt_truncate)
+#define _bt_keep_natts_fast	NBTS_FUNCTION(_bt_keep_natts_fast)
+
 /*
  * prototypes for functions in nbtree_spec.h
  */
-- 
2.42.1

From 199f5b0bfd6eb503403dfbbbee6a05517294470a Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 31 Jan 2024 02:06:41 +0100
Subject: [PATCH v16 5/6] btree: Optimize nbts_attiter for indexes with a
 single key attribute

This removes the index_getattr_nocache call path, which can have significant
overhead with branching, and replaces access to att->attcacheoff=0 with
constant 0.
---
 src/include/access/nbtree.h      | 46 ++++++++++++++++++++++++++++++--
 src/include/access/nbtree_spec.h | 43 +++++++++++++++++++++++++++++
 2 files changed, 87 insertions(+), 2 deletions(-)

diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index e1e80a8830..9579fed492 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1119,6 +1119,7 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
 #define NBTS_TYPE_CACHED CACHED
+#define NBTS_TYPE_SINGLE_KEYATT SINGLE_KEYATT
 
 /* Generate the specialized function headers */
 #define NBT_FILE "access/nbtree_specfuncs.h"
@@ -1130,20 +1131,61 @@ typedef struct BTOptions
 
 typedef enum NBTS_CTX {
 	NBTS_CTX_CACHED = 1, /* Equivalent to unspecialized code */
+	NBTS_CTX_SINGLE_KEYATT, /* Single key column index; cannot handle more */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	Assert(PointerIsValid(irel));
+
+	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+		return NBTS_CTX_SINGLE_KEYATT;
+
 	return NBTS_CTX_CACHED;
 }
 
+static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
+									bool *isNull)
+{
+	Datum	result;
+	if (IndexTupleHasNulls(tuple))
+	{
+		if (att_isnull(0, (bits8 *)(tuple) + sizeof(IndexTupleData)))
+		{
+			*isNull = true;
+			result = (Datum) 0;
+		}
+		else
+		{
+			*isNull = false;
+			result = fetchatt(TupleDescAttr(tupleDesc, 0),
+							  ((char *) tuple)
+							  + MAXALIGN(sizeof(IndexTupleData)
+							  + sizeof(IndexAttributeBitMapData)));
+		}
+	}
+	else
+	{
+		*isNull = false;
+		result = fetchatt(TupleDescAttr(tupleDesc, 0),
+						  ((char *) tuple)
+						  + MAXALIGN(sizeof(IndexTupleData)));
+	}
+
+	return result;
+}
+
 #define NBTS_CTX_NAME __nbts_ctx
 
 /* contextual specialization macros */
 #define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME PG_USED_FOR_ASSERTS_ONLY = _nbt_spec_context(rel)
 #define NBTS_SPECIALIZE_NAME(name) ( \
-	AssertMacro((NBTS_CTX_NAME) == NBTS_CTX_CACHED), \
-	NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+	(NBTS_CTX_NAME == NBTS_CTX_SINGLE_KEYATT) ? ( \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT) \
+	) : ( \
+		AssertMacro((NBTS_CTX_NAME) == NBTS_CTX_CACHED), \
+		NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+	) \
 )
 
 extern bool _btinsert_dispatch(Relation rel, Datum *values, bool *isnull,
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index c16659e603..4919f95e79 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -110,6 +110,49 @@
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 2: SINGLE_KEYATT
+ *
+ * Optimized access for indexes with a single key column.
+ *
+ * Note that this path may never be used for indexes with multiple key
+ * columns, because it only considers the first column (plus any TIDs for tie
+ * breaking).
+ */
+#define NBTS_TYPE NBTS_TYPE_SINGLE_KEYATT
+
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	Assert((endAttNum) == 1); ((void) (endAttNum)); \
+	if ((initAttNum) == 1) for (int spec_i = 0; spec_i < 1; spec_i++)
+
+#define nbts_attiter_attnum 1
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+( \
+	AssertMacro(spec_i == 0), \
+	_bt_getfirstatt(itup, tupDesc, &NBTS_MAKE_NAME(itup, isNull)) \
+)
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+
+/* un-define the optimization macros */
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * We're done with templating, so restore or create the macros which can be
  * used in non-template sources.
-- 
2.40.1

From eb720b80f2cacc6f3798230b074ec902a0ed907f Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 31 Jan 2024 01:27:06 +0100
Subject: [PATCH v16 2/6] btree: Introduce basic specialization

This introduces the basic infrastructure for specialization, and updates
call sites of the specialized functions to use the new infrastructure.

Note that actual meaningful code behaviour changes will happen in a later
commit, this only builds the scaffolds.

Specialized functions are written in _spec files, and their names are
defined as macros that produce either a specialized name token (when in a
specialized context), or an expression (which utilizes an in-scope
nbts_prep_ctx-prepared context) that evaluates to a function pointer which
points to the indicated function's variant which is most optimized for that
context's index key shape.
---
 contrib/amcheck/verify_nbtree.c               |  7 ++
 src/backend/access/nbtree/nbtdedup.c          |  4 +-
 src/backend/access/nbtree/nbtdedup_spec.c     |  2 +
 src/backend/access/nbtree/nbtinsert.c         |  6 +-
 src/backend/access/nbtree/nbtinsert_spec.c    |  3 +
 src/backend/access/nbtree/nbtpage.c           |  1 +
 src/backend/access/nbtree/nbtree.c            | 30 ++++++-
 src/backend/access/nbtree/nbtsearch.c         |  6 +-
 src/backend/access/nbtree/nbtsearch_spec.c    |  4 +
 src/backend/access/nbtree/nbtsort.c           |  5 +-
 src/backend/access/nbtree/nbtsort_spec.c      |  2 +
 src/backend/access/nbtree/nbtsplitloc.c       |  3 +
 src/backend/access/nbtree/nbtutils.c          |  3 +-
 src/backend/access/nbtree/nbtutils_spec.c     |  3 +
 src/backend/utils/sort/tuplesortvariants.c    |  6 +-
 .../utils/sort/tuplesortvariants_spec.c       |  3 +
 src/include/access/nbtree.h                   | 45 +++++++++-
 src/include/access/nbtree_spec.h              | 86 +++++++++++++++++++
 src/include/access/nbtree_specfuncs.h         | 16 ++++
 19 files changed, 226 insertions(+), 9 deletions(-)
 create mode 100644 src/include/access/nbtree_spec.h

diff --git a/contrib/amcheck/verify_nbtree.c b/contrib/amcheck/verify_nbtree.c
index 91caa53dd8..636ec1199e 100644
--- a/contrib/amcheck/verify_nbtree.c
+++ b/contrib/amcheck/verify_nbtree.c
@@ -1369,6 +1369,7 @@ bt_target_page_check(BtreeCheckState *state)
 	OffsetNumber offset;
 	OffsetNumber max;
 	BTPageOpaque topaque;
+	nbts_prep_ctx(state->rel);
 
 	/* last visible entry info for checking indexes with unique constraint */
 	int			lVis_i = -1;	/* the position of last visible item for
@@ -3066,6 +3067,7 @@ bt_rootdescend(BtreeCheckState *state, IndexTuple itup)
 	BTStack		stack;
 	Buffer		lbuf;
 	bool		exists;
+	nbts_prep_ctx(state->rel);
 
 	key = _bt_mkscankey(state->rel, itup);
 	Assert(key->heapkeyspace && key->scantid != NULL);
@@ -3164,6 +3166,7 @@ invariant_l_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	nbts_prep_ctx(state->rel);
 
 	Assert(!key->nextkey && key->backward);
 
@@ -3226,6 +3229,7 @@ invariant_leq_offset(BtreeCheckState *state, BTScanInsert key,
 					 OffsetNumber upperbound)
 {
 	int32		cmp;
+	nbts_prep_ctx(state->rel);
 
 	Assert(!key->nextkey && key->backward);
 
@@ -3249,6 +3253,7 @@ invariant_g_offset(BtreeCheckState *state, BTScanInsert key,
 				   OffsetNumber lowerbound)
 {
 	int32		cmp;
+	nbts_prep_ctx(state->rel);
 
 	Assert(!key->nextkey && key->backward);
 
@@ -3287,6 +3292,7 @@ invariant_l_nontarget_offset(BtreeCheckState *state, BTScanInsert key,
 {
 	ItemId		itemid;
 	int32		cmp;
+	nbts_prep_ctx(state->rel);
 
 	Assert(!key->nextkey && key->backward);
 
@@ -3522,6 +3528,7 @@ static inline BTScanInsert
 bt_mkscankey_pivotsearch(Relation rel, IndexTuple itup)
 {
 	BTScanInsert skey;
+	nbts_prep_ctx(rel);
 
 	skey = _bt_mkscankey(rel, itup);
 	skey->backward = true;
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index c0410f1792..74e5dc0905 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -28,7 +28,8 @@ static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-#include "nbtdedup_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtdedup_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -69,6 +70,7 @@ _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 	TM_IndexDeleteOp delstate;
 	bool		neverdedup;
 	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	nbts_prep_ctx(rel);
 
 	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
 	newitemsz += sizeof(ItemIdData);
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
index 056cf9908b..6db340dce6 100644
--- a/src/backend/access/nbtree/nbtdedup_spec.c
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -15,6 +15,8 @@
  *-------------------------------------------------------------------------
  */
 
+#define _bt_do_singleval NBTS_FUNCTION(_bt_do_singleval)
+
 static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
 							 OffsetNumber minoff, IndexTuple newitem);
 
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 013d473a74..31ed375bf1 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -67,7 +67,8 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-#include "nbtinsert_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtinsert_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -111,6 +112,7 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 	bool		inposting = false;
 	bool		prevalldead = true;
 	int			curposti = 0;
+	nbts_prep_ctx(rel);
 
 	/* Assume unique until we find a duplicate */
 	*is_unique = true;
@@ -943,6 +945,7 @@ _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
 	bool		newitemonleft,
 				isleaf,
 				isrightmost;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * origpage is the original page to be split.  leftpage is a temporary
@@ -2143,6 +2146,7 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
 	BTScanInsert itup_key = insertstate->itup_key;
 	Page		page = BufferGetPage(buffer);
 	BTPageOpaque opaque = BTPageGetOpaque(page);
+	nbts_prep_ctx(rel);
 
 	Assert(P_ISLEAF(opaque));
 	Assert(simpleonly || itup_key->heapkeyspace);
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
index b1f65ab1e6..64f62b41b8 100644
--- a/src/backend/access/nbtree/nbtinsert_spec.c
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -16,6 +16,9 @@
  *-------------------------------------------------------------------------
  */
 
+#define _bt_search_insert NBTS_FUNCTION(_bt_search_insert)
+#define _bt_findinsertloc NBTS_FUNCTION(_bt_findinsertloc)
+
 static BTStack _bt_search_insert(Relation rel, Relation heaprel,
 								 BTInsertState insertstate);
 static OffsetNumber _bt_findinsertloc(Relation rel,
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 01bbece6bf..780bb82e12 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -1805,6 +1805,7 @@ _bt_pagedel(Relation rel, Buffer leafbuf, BTVacState *vstate)
 	bool		rightsib_empty;
 	Page		page;
 	BTPageOpaque opaque;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Save original leafbuf block number from caller.  Only deleted blocks
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 1e53964166..4006ca1b2d 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -85,7 +85,8 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
-#include "nbtree_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtree_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -121,7 +122,7 @@ bthandler(PG_FUNCTION_ARGS)
 
 	amroutine->ambuild = btbuild;
 	amroutine->ambuildempty = btbuildempty;
-	amroutine->aminsert = btinsert;
+	amroutine->aminsert = _btinsert_dispatch;
 	amroutine->aminsertcleanup = NULL;
 	amroutine->ambulkdelete = btbulkdelete;
 	amroutine->amvacuumcleanup = btvacuumcleanup;
@@ -156,6 +157,8 @@ btbuildempty(Relation index)
 	BulkWriteState *bulkstate;
 	BulkWriteBuffer metabuf;
 
+	nbt_opt_specialize(index);
+
 	bulkstate = smgr_bulk_start_rel(index, INIT_FORKNUM);
 
 	/* Construct metapage. */
@@ -166,6 +169,27 @@ btbuildempty(Relation index)
 	smgr_bulk_finish(bulkstate);
 }
 
+/*
+ *	_btinsert_dispatch() -- dispatcher for specialized btinsert functions.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+_btinsert_dispatch(Relation rel, Datum *values, bool *isnull,
+				   ItemPointer ht_ctid, Relation heapRel,
+				   IndexUniqueCheck checkUnique,
+				   bool indexUnchanged,
+				   IndexInfo *indexInfo)
+{
+	nbts_prep_ctx(rel);
+
+	_bt_specialize(rel);
+
+	return btinsert(rel, values, isnull, ht_ctid, heapRel, checkUnique,
+					indexUnchanged, indexInfo);
+}
+
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
@@ -306,6 +330,7 @@ btbeginscan(Relation rel, int nkeys, int norderbys)
 {
 	IndexScanDesc scan;
 	BTScanOpaque so;
+	nbt_opt_specialize(rel);
 
 	/* no order by operators allowed */
 	Assert(norderbys == 0);
@@ -750,6 +775,7 @@ btbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 {
 	Relation	rel = info->index;
 	BTCycleId	cycleid;
+	nbt_opt_specialize(rel);
 
 	/* allocate stats if first time through, else re-use existing struct */
 	if (stats == NULL)
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index e46ed8f377..2adb73aa0d 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -44,7 +44,8 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
-#include "nbtsearch_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtsearch_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -174,6 +175,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 	StrategyNumber strat_total;
 	BTScanPosItem *currItem;
 	BlockNumber blkno;
+	nbts_prep_ctx(rel);
 
 	Assert(!BTScanPosIsValid(so->currPos));
 
@@ -987,6 +989,7 @@ _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
+	nbts_prep_ctx(rel);
 
 	if (ScanDirectionIsForward(dir))
 	{
@@ -1377,6 +1380,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
 	BTPageOpaque opaque;
 	OffsetNumber start;
 	BTScanPosItem *currItem;
+	nbts_prep_ctx(rel);
 
 	/*
 	 * Scan down to the leftmost or rightmost leaf page.  This is a simplified
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index a42aa4bb11..d65765ca23 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -16,6 +16,10 @@
  *-------------------------------------------------------------------------
  */
 
+#define _bt_binsrch		NBTS_FUNCTION(_bt_binsrch)
+#define _bt_moveright	NBTS_FUNCTION(_bt_moveright)
+#define _bt_readpage	NBTS_FUNCTION(_bt_readpage)
+
 static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
 static Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
 							Buffer buf, bool forupdate, BTStack stack,
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index f2c96af23b..9311bd00f5 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -283,7 +283,8 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
-#include "nbtsort_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtsort_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -535,6 +536,7 @@ static void
 _bt_leafbuild(BTSpool *btspool, BTSpool *btspool2)
 {
 	BTWriteState wstate;
+	nbts_prep_ctx(btspool->index);
 
 #ifdef BTREE_BUILD_STATS
 	if (log_btree_build_stats)
@@ -791,6 +793,7 @@ _bt_buildadd(BTWriteState *wstate, BTPageState *state, IndexTuple itup,
 	Size		pgspc;
 	Size		itupsz;
 	bool		isleaf;
+	nbts_prep_ctx(wstate->index);
 
 	/*
 	 * This is a handy place to check for cancel interrupts during the btree
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index c9d03d771f..77829a23e0 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -16,6 +16,8 @@
  *-------------------------------------------------------------------------
  */
 
+#define _bt_load NBTS_FUNCTION(_bt_load)
+
 static void _bt_load(BTWriteState *wstate,
 					 BTSpool *btspool, BTSpool *btspool2);
 
diff --git a/src/backend/access/nbtree/nbtsplitloc.c b/src/backend/access/nbtree/nbtsplitloc.c
index 1f40d40263..4f02c308f9 100644
--- a/src/backend/access/nbtree/nbtsplitloc.c
+++ b/src/backend/access/nbtree/nbtsplitloc.c
@@ -634,6 +634,7 @@ _bt_afternewitemoff(FindSplitData *state, OffsetNumber maxoff,
 	ItemId		itemid;
 	IndexTuple	tup;
 	int			keepnatts;
+	nbts_prep_ctx(state->rel);
 
 	Assert(state->is_leaf && !state->is_rightmost);
 
@@ -940,6 +941,7 @@ _bt_strategy(FindSplitData *state, SplitPoint *leftpage,
 			   *rightinterval;
 	int			perfectpenalty;
 	int			indnkeyatts = IndexRelationGetNumberOfKeyAttributes(state->rel);
+	nbts_prep_ctx(state->rel);
 
 	/* Assume that alternative strategy won't be used for now */
 	*strategy = SPLIT_DEFAULT;
@@ -1132,6 +1134,7 @@ _bt_split_penalty(FindSplitData *state, SplitPoint *split)
 {
 	IndexTuple	lastleft;
 	IndexTuple	firstright;
+	nbts_prep_ctx(state->rel);
 
 	if (!state->is_leaf)
 	{
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index 8cb0ee2351..84253b8004 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -50,7 +50,8 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
 
-#include "nbtutils_spec.c"
+#define NBT_FILE "../../backend/access/nbtree/nbtutils_spec.c"
+#include "access/nbtree_spec.h"
 
 /*
  * free a retracement stack made by _bt_search.
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index 29a9ce3664..38e27f1757 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -16,6 +16,9 @@
  *-------------------------------------------------------------------------
  */
 
+#define _bt_check_rowcompare	NBTS_FUNCTION(_bt_check_rowcompare)
+#define _bt_keep_natts			NBTS_FUNCTION(_bt_keep_natts)
+
 static bool _bt_check_rowcompare(ScanKey skey,
 								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
 								 ScanDirection dir, bool *continuescan);
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index 6da7d7fd58..dfd3c31d47 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -159,7 +159,8 @@ typedef struct BrinSortTuple
 /* Size of the BrinSortTuple, given length of the BrinTuple. */
 #define BRINSORTTUPLE_SIZE(len)		(offsetof(BrinSortTuple, tuple) + (len))
 
-#include "tuplesortvariants_spec.c"
+#define NBT_FILE "../../backend/utils/sort/tuplesortvariants_spec.c"
+#include "access/nbtree_spec.h"
 
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
@@ -249,6 +250,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
 	MemoryContext oldcontext;
 	TuplesortClusterArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	Assert(indexRel->rd_rel->relam == BTREE_AM_OID);
 
@@ -361,6 +363,7 @@ tuplesort_begin_index_btree(Relation heapRel,
 	TuplesortIndexBTreeArg *arg;
 	MemoryContext oldcontext;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
@@ -496,6 +499,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 	MemoryContext oldcontext;
 	TuplesortIndexBTreeArg *arg;
 	int			i;
+	nbts_prep_ctx(indexRel);
 
 	oldcontext = MemoryContextSwitchTo(base->maincontext);
 	arg = (TuplesortIndexBTreeArg *) palloc(sizeof(TuplesortIndexBTreeArg));
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 76cabb207e..705da09329 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -16,6 +16,9 @@
  *-------------------------------------------------------------------------
  */
 
+#define comparetup_index_btree NBTS_FUNCTION(comparetup_index_btree)
+#define comparetup_index_btree_tiebreak NBTS_FUNCTION(comparetup_index_btree_tiebreak)
+
 static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 								   Tuplesortstate *state);
 static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 63e245dcbc..e1e80a8830 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1118,7 +1118,50 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
-#include "access/nbtree_specfuncs.h"
+#define NBTS_TYPE_CACHED CACHED
+
+/* Generate the specialized function headers */
+#define NBT_FILE "access/nbtree_specfuncs.h"
+#include "access/nbtree_spec.h"
+
+/*
+ * Further specialization helpers and definitions
+ */
+
+typedef enum NBTS_CTX {
+	NBTS_CTX_CACHED = 1, /* Equivalent to unspecialized code */
+} NBTS_CTX;
+
+static inline NBTS_CTX _nbt_spec_context(Relation irel)
+{
+	return NBTS_CTX_CACHED;
+}
+
+#define NBTS_CTX_NAME __nbts_ctx
+
+/* contextual specialization macros */
+#define NBTS_MAKE_CTX(rel) const NBTS_CTX NBTS_CTX_NAME PG_USED_FOR_ASSERTS_ONLY = _nbt_spec_context(rel)
+#define NBTS_SPECIALIZE_NAME(name) ( \
+	AssertMacro((NBTS_CTX_NAME) == NBTS_CTX_CACHED), \
+	NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+)
+
+extern bool _btinsert_dispatch(Relation rel, Datum *values, bool *isnull,
+							   ItemPointer ht_ctid, Relation heapRel,
+							   IndexUniqueCheck checkUnique,
+							   bool indexUnchanged,
+							   struct IndexInfo *indexInfo);
+
+static inline
+void nbt_opt_specialize(Relation rel)
+{
+	Assert(PointerIsValid(rel));
+	if (unlikely((rel)->rd_indam->aminsert == _btinsert_dispatch))
+	{
+		nbts_prep_ctx(rel);
+		_bt_specialize(rel);
+	}
+}
 
 /*
  * external entry points for btree, in nbtree.c
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
new file mode 100644
index 0000000000..731f2fb946
--- /dev/null
+++ b/src/include/access/nbtree_spec.h
@@ -0,0 +1,86 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_specialize.h
+ *	  header file for postgres btree access method implementation.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/nbtree_specialize.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Specialize key-accessing functions and the hot code around those. The file
+ * that's marked for specialization is either
+ * - NBTS_HEADER, a quoted header inclusion path; or
+ * - NBTS_FILE, the include path of the to-be-specialized code relative to
+ *		the access/nbtree_spec.h file.
+ *
+ * Specialized files define their functions like usual, with an additional
+ * requirement that they #define their function name at the top, with
+ * #define funcname NBTS_FUNCTION(funcname).
+ */
+
+#if defined(NBT_FILE)
+#define NBT_SPECIALIZE_FILE NBT_FILE
+#else
+#error "No specializable file defined"
+#endif
+
+/* how do we make names? */
+#define NBTS_MAKE_PREFIX(a) CppConcat(a,_)
+#define NBTS_MAKE_NAME_(a,b) CppConcat(a,b)
+#define NBTS_MAKE_NAME(a,b) NBTS_MAKE_NAME_(NBTS_MAKE_PREFIX(a),b)
+
+
+/*
+ * Protections against multiple inclusions - the definition of this macro is
+ * different for files included by this file as template, versus those that
+ * include this file for the definitions, so we redefine these macros at top and
+ * bottom.
+ */
+#ifdef NBTS_FUNCTION
+#undef NBTS_FUNCTION
+#endif
+#define NBTS_FUNCTION(name) NBTS_MAKE_NAME(name, NBTS_TYPE)
+
+/* In a specialized file, specialization contexts are meaningless */
+#ifdef nbts_prep_ctx
+#undef nbts_prep_ctx
+#endif
+
+/*
+ * Specialization 1: CACHED
+ *
+ * Multiple key columns, optimized access for attcacheoff -cacheable offsets.
+ */
+#define NBTS_TYPE NBTS_TYPE_CACHED
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+
+/*
+ * We're done with templating, so restore or create the macros which can be
+ * used in non-template sources.
+ */
+#define nbts_prep_ctx(rel) NBTS_MAKE_CTX(rel)
+
+/*
+ * from here on all NBTS_FUNCTIONs are from specialized function names that
+ * are being called. Change the result of those macros from a direct call
+ * call to a conditional call to the right place, depending on the correct
+ * context.
+ */
+#undef NBTS_FUNCTION
+#define NBTS_FUNCTION(name) NBTS_SPECIALIZE_NAME(name)
+
+/* cleanup unwanted definitions from file inclusion */
+#undef NBT_SPECIALIZE_FILE
+#ifdef NBT_HEADERS
+#undef NBT_HEADERS
+#endif
+#ifdef NBT_FILE
+#undef NBT_FILE
+#endif
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
index d2ca62cb3b..00b718324e 100644
--- a/src/include/access/nbtree_specfuncs.h
+++ b/src/include/access/nbtree_specfuncs.h
@@ -1,3 +1,19 @@
+/*
+ * prototypes for functions that are included in nbtree.h
+ */
+
+#define _bt_specialize		NBTS_FUNCTION(_bt_specialize)
+#define btinsert			NBTS_FUNCTION(btinsert)
+#define _bt_dedup_pass		NBTS_FUNCTION(_bt_dedup_pass)
+#define _bt_doinsert		NBTS_FUNCTION(_bt_doinsert)
+#define _bt_search			NBTS_FUNCTION(_bt_search)
+#define _bt_binsrch_insert	NBTS_FUNCTION(_bt_binsrch_insert)
+#define _bt_compare			NBTS_FUNCTION(_bt_compare)
+#define _bt_mkscankey		NBTS_FUNCTION(_bt_mkscankey)
+#define _bt_checkkeys		NBTS_FUNCTION(_bt_checkkeys)
+#define _bt_truncate		NBTS_FUNCTION(_bt_truncate)
+#define _bt_keep_natts_fast	NBTS_FUNCTION(_bt_keep_natts_fast)
+
 /*
  * prototypes for functions in nbtree_spec.h
  */
-- 
2.40.1

From 3eebb28da2b1e2e8a130ee62b9e96981684eff95 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 31 Jan 2024 01:40:40 +0100
Subject: [PATCH v16 3/6] btree: Introduce attribute iterator specialization
 infrastructure

This allows the specialization framework to utilize different optimized
attribute iteration methods based on key shape, e.g. one that utilizes
attcacheoff; one that doens't need to calculate offset because of the
use of only one key attribute, or one that incrementally finds next
offsets for each attribute in the tuple.

Even though not all nbt*_spec functions have been updated, these functions
can now directly call (and potentially inline, and optimize for) the
specialized functions they call, instead of having to determine the right
specialization locally based on the (potentially locally unavailable) index
relation, making the specialization of those functions still worth
specializing/duplicating.
---
 src/backend/access/nbtree/nbtsearch_spec.c    | 17 +++--
 src/backend/access/nbtree/nbtsort_spec.c      | 24 +++----
 src/backend/access/nbtree/nbtutils_spec.c     | 62 ++++++++++++-------
 .../utils/sort/tuplesortvariants_spec.c       | 53 +++++++++-------
 src/include/access/nbtree_spec.h              | 49 +++++++++++++++
 5 files changed, 141 insertions(+), 64 deletions(-)

diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
index d65765ca23..cf5e559c28 100644
--- a/src/backend/access/nbtree/nbtsearch_spec.c
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -581,6 +581,7 @@ _bt_compare(Relation rel,
 	int			ncmpkey;
 	int			ntupatts;
 	int32		result;
+	nbts_attiterdeclare(itup);
 
 	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
 	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
@@ -611,24 +612,28 @@ _bt_compare(Relation rel,
 	ncmpkey = Min(ntupatts, key->keysz);
 	Assert(key->heapkeyspace || ncmpkey == key->keysz);
 	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+
 	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, ncmpkey)
 	{
 		Datum		datum;
-		bool		isNull;
 
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+		datum = nbts_attiter_nextattdatum(itup, itupdesc);
 
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		/* key is NULL */
+		if (scankey->sk_flags & SK_ISNULL)
 		{
-			if (isNull)
+			if (nbts_attiter_curattisnull(itup))
 				result = 0;		/* NULL "=" NULL */
 			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = -1;	/* NULL "<" NOT_NULL */
 			else
 				result = 1;		/* NULL ">" NOT_NULL */
 		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		/* key is NOT_NULL and item is NULL */
+		else if (nbts_attiter_curattisnull(itup))
 		{
 			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
 				result = 1;		/* NOT_NULL ">" NULL */
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
index 77829a23e0..8f5c255981 100644
--- a/src/backend/access/nbtree/nbtsort_spec.c
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -34,8 +34,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 				itup2 = NULL;
 	bool		load1;
 	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
 	SortSupport sortKeys;
 	int64		tuples_done = 0;
 	bool		deduplicate;
@@ -59,7 +58,7 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 		/* Prepare SortSupport data for each column */
 		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
 
-		for (i = 0; i < keysz; i++)
+		for (int i = 0; i < keysz; i++)
 		{
 			SortSupport sortKey = sortKeys + i;
 			ScanKey		scanKey = wstate->inskey->scankeys + i;
@@ -92,21 +91,24 @@ _bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
 			else if (itup != NULL)
 			{
 				int32		compare = 0;
+				nbts_attiterdeclare(itup);
+				nbts_attiterdeclare(itup2);
 
-				for (i = 1; i <= keysz; i++)
+				nbts_attiterinit(itup, 1, tupdes);
+				nbts_attiterinit(itup2, 1, tupdes);
+
+				nbts_foreachattr(1, keysz)
 				{
 					SortSupport entry;
 					Datum		attrDatum1,
 								attrDatum2;
-					bool		isNull1,
-								isNull2;
 
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+					entry = sortKeys + nbts_attiter_attnum - 1;
+					attrDatum1 = nbts_attiter_nextattdatum(itup, tupdes);
+					attrDatum2 = nbts_attiter_nextattdatum(itup2, tupdes);
 
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
+					compare = ApplySortComparator(attrDatum1, nbts_attiter_curattisnull(itup),
+												  attrDatum2, nbts_attiter_curattisnull(itup2),
 												  entry);
 					if (compare > 0)
 					{
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
index 38e27f1757..fad68250de 100644
--- a/src/backend/access/nbtree/nbtutils_spec.c
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -56,7 +56,7 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	int			indnkeyatts;
 	int16	   *indoption;
 	int			tupnatts;
-	int			i;
+	nbts_attiterdeclare(itup);
 
 	itupdesc = RelationGetDescr(rel);
 	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
@@ -87,7 +87,10 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 	key->scantid = key->heapkeyspace && itup ?
 		BTreeTupleGetHeapTID(itup) : NULL;
 	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
+
+	nbts_attiterinit(itup, 1, itupdesc);
+
+	nbts_foreachattr(1, indnkeyatts)
 	{
 		FmgrInfo   *procinfo;
 		Datum		arg;
@@ -98,27 +101,30 @@ _bt_mkscankey(Relation rel, IndexTuple itup)
 		 * We can use the cached (default) support procs since no cross-type
 		 * comparison can be needed.
 		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+		procinfo = index_getprocinfo(rel, nbts_attiter_attnum, BTORDER_PROC);
 
 		/*
 		 * Key arguments built from truncated attributes (or when caller
 		 * provides no tuple) are defensively represented as NULL values. They
 		 * should never be used.
 		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		if (nbts_attiter_attnum <= tupnatts)
+		{
+			arg = nbts_attiter_nextattdatum(itup, itupdesc);
+			null = nbts_attiter_curattisnull(itup);
+		}
 		else
 		{
 			arg = (Datum) 0;
 			null = true;
 		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
+		flags = (null ? SK_ISNULL : 0) | (indoption[nbts_attiter_attnum - 1] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[nbts_attiter_attnum - 1],
 									   flags,
-									   (AttrNumber) (i + 1),
+									   (AttrNumber) nbts_attiter_attnum,
 									   InvalidStrategy,
 									   InvalidOid,
-									   rel->rd_indcollation[i],
+									   rel->rd_indcollation[nbts_attiter_attnum - 1],
 									   procinfo,
 									   arg);
 		/* Record if any key attribute is NULL (or truncated) */
@@ -712,6 +718,8 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keepnatts;
 	ScanKey		scankey;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	/*
 	 * _bt_compare() treats truncated key attributes as having the value minus
@@ -723,20 +731,22 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 
 	scankey = itup_key->scankeys;
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, nkeyatts)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
 											scankey->sk_collation,
 											datum1,
@@ -744,6 +754,7 @@ _bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
 			break;
 
 		keepnatts++;
+		scankey++;
 	}
 
 	/*
@@ -784,24 +795,27 @@ _bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
 	TupleDesc	itupdesc = RelationGetDescr(rel);
 	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
 	int			keepnatts;
+	nbts_attiterdeclare(lastleft);
+	nbts_attiterdeclare(firstright);
 
 	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
+	nbts_attiterinit(lastleft, 1, itupdesc);
+	nbts_attiterinit(firstright, 1, itupdesc);
+
+	nbts_foreachattr(1, keysz)
 	{
 		Datum		datum1,
 					datum2;
-		bool		isNull1,
-					isNull2;
 		Form_pg_attribute att;
 
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
+		datum1 = nbts_attiter_nextattdatum(lastleft, itupdesc);
+		datum2 = nbts_attiter_nextattdatum(firstright, itupdesc);
+		att = TupleDescAttr(itupdesc, nbts_attiter_attnum - 1);
 
-		if (isNull1 != isNull2)
+		if (nbts_attiter_curattisnull(lastleft) != nbts_attiter_curattisnull(firstright))
 			break;
 
-		if (!isNull1 &&
+		if (!nbts_attiter_curattisnull(lastleft) &&
 			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
 			break;
 
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
index 705da09329..cf262eee2d 100644
--- a/src/backend/utils/sort/tuplesortvariants_spec.c
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -66,47 +66,54 @@ comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
 	bool		equal_hasnull = false;
 	int			nkey;
 	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
+	nbts_attiterdeclare(tuple1);
+	nbts_attiterdeclare(tuple2);
 
 	tuple1 = (IndexTuple) a->tuple;
 	tuple2 = (IndexTuple) b->tuple;
 	keysz = base->nKeys;
 	tupDes = RelationGetDescr(arg->index.indexRel);
 
-	if (sortKey->abbrev_converter)
+	if (!sortKey->abbrev_converter)
 	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
+		nkey = 2;
+		sortKey++;
+	}
+	else
+	{
+		nkey = 1;
 	}
 
 	/* they are equal, so we only need to examine one null flag */
 	if (a->isnull1)
 		equal_hasnull = true;
 
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	nbts_attiterinit(tuple1, nkey, tupDes);
+	nbts_attiterinit(tuple2, nkey, tupDes);
+
+	nbts_foreachattr(nkey, keysz)
 	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+		Datum	datum1,
+				datum2;
+		datum1 = nbts_attiter_nextattdatum(tuple1, tupDes);
+		datum2 = nbts_attiter_nextattdatum(tuple2, tupDes);
+
+		if (nbts_attiter_attnum == 1)
+			compare = ApplySortAbbrevFullComparator(datum1, nbts_attiter_curattisnull(tuple1),
+													datum2, nbts_attiter_curattisnull(tuple2),
+													sortKey);
+		else
+			compare = ApplySortComparator(datum1, nbts_attiter_curattisnull(tuple1),
+										  datum2, nbts_attiter_curattisnull(tuple2),
+										  sortKey);
 
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
 		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
+			return compare;
 
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
+		if (nbts_attiter_curattisnull(tuple1))
 			equal_hasnull = true;
+
+		sortKey++;
 	}
 
 	/*
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 731f2fb946..c16659e603 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -20,6 +20,33 @@
  * Specialized files define their functions like usual, with an additional
  * requirement that they #define their function name at the top, with
  * #define funcname NBTS_FUNCTION(funcname).
+ *
+ * Key attribute iteration is specialized through the use of the following
+ * macros:
+ *
+ * - nbts_attiterdeclare(itup)
+ *   Declare the variables required to iterate over the provided IndexTuple's
+ *   key attributes. Many tuples may have their attributes iterated over at the
+ *   same time.
+ * - nbts_attiterinit(itup, initAttNum, tupDesc)
+ *   Initialize the attribute iterator for the provided IndexTuple at
+ *   the provided AttributeNumber.
+ * - nbts_foreachattr(initAttNum, endAttNum)
+ *   Start a loop over the attributes, starting at initAttNum and ending at
+ *   endAttNum, inclusive. It also takes care of truncated attributes.
+ * - nbts_attiter_attnum
+ *   The current attribute number
+ * - nbts_attiter_nextattdatum(itup, tupDesc)
+ *   Updates the attribute iterator state to the next attribute. Returns the
+ *   datum of the next attribute, which might be null (see below)
+ * - nbts_attiter_curattisnull(itup)
+ *   Returns whether the result from the last nbts_attiter_nextattdatum is
+ *   null.
+ * - nbts_context(irel)
+ *   Constructs a context that is used to call specialized functions.
+ *   Note that this is unneeded in paths that are inaccessible to unspecialized
+ *   code paths (i.e. code included through nbtree_spec.h), because that
+ *   always calls the optimized functions directly.
  */
 
 #if defined(NBT_FILE)
@@ -57,9 +84,31 @@
  */
 #define NBTS_TYPE NBTS_TYPE_CACHED
 
+#define nbts_attiterdeclare(itup) \
+	bool	NBTS_MAKE_NAME(itup, isNull)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) do {} while (false)
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_getattr((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, isNull)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, isNull)
+
 #include NBT_SPECIALIZE_FILE
 
 #undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
 
 /*
  * We're done with templating, so restore or create the macros which can be
-- 
2.40.1

From d4e36859b60128d84b99f5ed3d4797a585eb9c43 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Thu, 12 Jan 2023 21:34:36 +0100
Subject: [PATCH v16 4/6] Add an attcacheoff-populating function

It populates attcacheoff-capable attributes with the correct offset,
and fills attributes whose offset is uncacheable with an 'uncacheable'
indicator value; as opposed to -1 which signals "unknown".

This allows users of the API to remove redundant cycles that try to
cache the offset of attributes - instead of O(N-attrs) operations, this
one only requires a O(1) check for repeat calls.
---
 src/backend/access/common/tupdesc.c | 111 ++++++++++++++++++++++++++++
 src/include/access/tupdesc.h        |   2 +
 2 files changed, 113 insertions(+)

diff --git a/src/backend/access/common/tupdesc.c b/src/backend/access/common/tupdesc.c
index bc80caee11..3f3816b882 100644
--- a/src/backend/access/common/tupdesc.c
+++ b/src/backend/access/common/tupdesc.c
@@ -890,3 +890,114 @@ ResOwnerPrintTupleDesc(Datum res)
 	return psprintf("TupleDesc %p (%u,%d)",
 					tupdesc, tupdesc->tdtypeid, tupdesc->tdtypmod);
 }
+
+/*
+ * PopulateTupleDescCacheOffsets
+ *
+ * Populate the attcacheoff fields of a TupleDesc, returning the last
+ * attcacheoff with a valid offset value.
+ *
+ * Populates attcacheoff with a negative cache value when no offset
+ * can be calculated (due to e.g. variable length attributes).
+ * The negative value is a value relative to the last cacheable attribute
+ *   attcacheoff = -1 - (thisattno - cachedattno)
+ * so that the last attribute with cached offset can be found with
+ *   cachedattno = attcacheoff + 1 + thisattno
+ *   
+ * The value returned is the AttrNumber of the last (1-based) attribute that
+ * had its offset cached.
+ * 
+ * When the TupleDesc has 0 attributes, it returns 0.
+ */
+AttrNumber
+PopulateTupleDescCacheOffsets(TupleDesc desc)
+{
+	int			numberOfAttributes = desc->natts;
+	AttrNumber	currAttNo, lastCachedAttNo;
+
+	if (numberOfAttributes == 0)
+		return 0;
+
+	/* Non-negative value: this attribute is cached */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff >= 0)
+		return (AttrNumber) desc->natts;
+	/*
+	 * Attribute has been filled with relative offset to last cached value, but
+	 * it itself is unreachable.
+	 */
+	if (TupleDescAttr(desc, desc->natts - 1)->attcacheoff != -1)
+		return (AttrNumber) (TupleDescAttr(desc, desc->natts - 1)->attcacheoff + 1 + desc->natts);
+
+	/* last attribute of the tupledesc may or may not support attcacheoff */
+
+	/*
+	 * First attribute always starts at offset zero.
+	 */
+	TupleDescAttr(desc, 0)->attcacheoff = 0;
+
+	currAttNo = 1;
+	/*
+	 * Other code may have populated the value previously.
+	 * Skip all positive offsets to get to the first attribute without
+	 * attcacheoff.
+	 */
+	while (currAttNo < numberOfAttributes &&
+		   TupleDescAttr(desc, currAttNo)->attcacheoff >= 0)
+		currAttNo++;
+
+	/*
+	 * Cache offset is undetermined. Start calculating offsets if possible.
+	 * 
+	 * When we exit this block, currAttNo will point at the first uncacheable
+	 * attribute, or past the end of the attribute array.
+	 */
+	if (currAttNo < numberOfAttributes &&
+		TupleDescAttr(desc, currAttNo)->attcacheoff == -1)
+	{
+		Form_pg_attribute att = TupleDescAttr(desc, currAttNo - 1);
+		int32 off = att->attcacheoff;
+
+		if (att->attlen >= 0) {
+			off += att->attlen;
+
+			while (currAttNo < numberOfAttributes)
+			{
+				att = TupleDescAttr(desc, currAttNo);
+
+				if (att->attlen < 0)
+				{
+					if (off == att_align_nominal(off, att->attalign))
+					{
+						att->attcacheoff = off;
+						currAttNo++;
+					}
+					break;
+				}
+
+				off = att_align_nominal(off, att->attalign);
+				att->attcacheoff = off;
+				off += att->attlen;
+				currAttNo++;
+			}
+		}
+	}
+
+	Assert(currAttNo == numberOfAttributes || (
+		currAttNo < numberOfAttributes
+		&& TupleDescAttr(desc, (currAttNo - 1))->attcacheoff >= 0
+		&& TupleDescAttr(desc, currAttNo)->attcacheoff == -1
+	));
+	/*
+	 * No cacheable offsets left. Fill the rest with negative cache values,
+	 * but return the latest cached offset.
+	 */
+	lastCachedAttNo = currAttNo;
+
+	while (currAttNo < numberOfAttributes)
+	{
+		TupleDescAttr(desc, currAttNo)->attcacheoff = -1 - (currAttNo - lastCachedAttNo);
+		currAttNo++;
+	}
+
+	return lastCachedAttNo;
+}
\ No newline at end of file
diff --git a/src/include/access/tupdesc.h b/src/include/access/tupdesc.h
index 3d767dde65..2ef4613719 100644
--- a/src/include/access/tupdesc.h
+++ b/src/include/access/tupdesc.h
@@ -151,4 +151,6 @@ extern TupleDesc BuildDescFromLists(const List *names, const List *types, const
 
 extern Node *TupleDescGetDefault(TupleDesc tupdesc, AttrNumber attnum);
 
+extern AttrNumber PopulateTupleDescCacheOffsets(TupleDesc desc);
+
 #endif							/* TUPDESC_H */
-- 
2.40.1

From 5484e503d518bd3e500f011f9b54676ada249618 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 11 Jan 2023 02:57:21 +0100
Subject: [PATCH v16 1/6] btree specialization: Prepare code for
 specialization.

nbtree index keys are not all made the same, and a significant amount of
time is spent in code that exists only to deal with various key shapes. By
allowing the specialization of functions based on the key shape, we can
remove or reduce these causes of overhead.

This commit moves the various specializable functions into "_spec"
sourcefiles. Later commits will further modify these sources, mostly
mechanically, in a way that produces several optimized variants of the
functions for several distinct index key shapes.
---
 src/backend/access/nbtree/nbtdedup.c          |  298 +----
 src/backend/access/nbtree/nbtdedup_spec.c     |  315 +++++
 src/backend/access/nbtree/nbtinsert.c         |  553 +--------
 src/backend/access/nbtree/nbtinsert_spec.c    |  573 +++++++++
 src/backend/access/nbtree/nbtree.c            |   28 +-
 src/backend/access/nbtree/nbtree_spec.c       |   53 +
 src/backend/access/nbtree/nbtsearch.c         | 1074 +---------------
 src/backend/access/nbtree/nbtsearch_spec.c    | 1090 +++++++++++++++++
 src/backend/access/nbtree/nbtsort.c           |  252 +---
 src/backend/access/nbtree/nbtsort_spec.c      |  269 ++++
 src/backend/access/nbtree/nbtutils.c          |  791 +-----------
 src/backend/access/nbtree/nbtutils_spec.c     |  809 ++++++++++++
 src/backend/utils/sort/tuplesortvariants.c    |  151 +--
 .../utils/sort/tuplesortvariants_spec.c       |  172 +++
 src/include/access/nbtree.h                   |   27 +-
 src/include/access/nbtree_specfuncs.h         |   43 +
 src/tools/pginclude/cpluspluscheck            |    2 +
 src/tools/pginclude/headerscheck              |    2 +
 18 files changed, 3338 insertions(+), 3164 deletions(-)
 create mode 100644 src/backend/access/nbtree/nbtdedup_spec.c
 create mode 100644 src/backend/access/nbtree/nbtinsert_spec.c
 create mode 100644 src/backend/access/nbtree/nbtree_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsearch_spec.c
 create mode 100644 src/backend/access/nbtree/nbtsort_spec.c
 create mode 100644 src/backend/access/nbtree/nbtutils_spec.c
 create mode 100644 src/backend/utils/sort/tuplesortvariants_spec.c
 create mode 100644 src/include/access/nbtree_specfuncs.h

diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 456d86b51c..c0410f1792 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -22,260 +22,13 @@
 
 static void _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 										   TM_IndexDeleteOp *delstate);
-static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
-							 OffsetNumber minoff, IndexTuple newitem);
 static void _bt_singleval_fillfactor(Page page, BTDedupState state,
 									 Size newitemsz);
 #ifdef USE_ASSERT_CHECKING
 static bool _bt_posting_valid(IndexTuple posting);
 #endif
 
-/*
- * Perform a deduplication pass.
- *
- * The general approach taken here is to perform as much deduplication as
- * possible to free as much space as possible.  Note, however, that "single
- * value" strategy is used for !bottomupdedup callers when the page is full of
- * tuples of a single value.  Deduplication passes that apply the strategy
- * will leave behind a few untouched tuples at the end of the page, preparing
- * the page for an anticipated page split that uses nbtsplitloc.c's own single
- * value strategy.  Our high level goal is to delay merging the untouched
- * tuples until after the page splits.
- *
- * When a call to _bt_bottomupdel_pass() just took place (and failed), our
- * high level goal is to prevent a page split entirely by buying more time.
- * We still hope that a page split can be avoided altogether.  That's why
- * single value strategy is not even considered for bottomupdedup callers.
- *
- * The page will have to be split if we cannot successfully free at least
- * newitemsz (we also need space for newitem's line pointer, which isn't
- * included in caller's newitemsz).
- *
- * Note: Caller should have already deleted all existing items with their
- * LP_DEAD bits set.
- */
-void
-_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
-			   bool bottomupdedup)
-{
-	OffsetNumber offnum,
-				minoff,
-				maxoff;
-	Page		page = BufferGetPage(buf);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	Page		newpage;
-	BTDedupState state;
-	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
-	bool		singlevalstrat = false;
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-
-	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
-	newitemsz += sizeof(ItemIdData);
-
-	/*
-	 * Initialize deduplication state.
-	 *
-	 * It would be possible for maxpostingsize (limit on posting list tuple
-	 * size) to be set to one third of the page.  However, it seems like a
-	 * good idea to limit the size of posting lists to one sixth of a page.
-	 * That ought to leave us with a good split point when pages full of
-	 * duplicates can be split several times.
-	 */
-	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
-	state->deduplicate = true;
-	state->nmaxitems = 0;
-	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
-	/* Metadata about base tuple of current pending posting list */
-	state->base = NULL;
-	state->baseoff = InvalidOffsetNumber;
-	state->basetupsize = 0;
-	/* Metadata about current pending posting list TIDs */
-	state->htids = palloc(state->maxpostingsize);
-	state->nhtids = 0;
-	state->nitems = 0;
-	/* Size of all physical tuples to be replaced by pending posting list */
-	state->phystupsize = 0;
-	/* nintervals should be initialized to zero */
-	state->nintervals = 0;
-
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * Consider applying "single value" strategy, though only if the page
-	 * seems likely to be split in the near future
-	 */
-	if (!bottomupdedup)
-		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
-
-	/*
-	 * Deduplicate items from page, and write them to newpage.
-	 *
-	 * Copy the original page's LSN into newpage copy.  This will become the
-	 * updated version of the page.  We need this because XLogInsert will
-	 * examine the LSN and possibly dump it in a page image.
-	 */
-	newpage = PageGetTempPageCopySpecial(page);
-	PageSetLSN(newpage, PageGetLSN(page));
-
-	/* Copy high key, if any */
-	if (!P_RIGHTMOST(opaque))
-	{
-		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
-		Size		hitemsz = ItemIdGetLength(hitemid);
-		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
-
-		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
-						false, false) == InvalidOffsetNumber)
-			elog(ERROR, "deduplication failed to add highkey");
-	}
-
-	for (offnum = minoff;
-		 offnum <= maxoff;
-		 offnum = OffsetNumberNext(offnum))
-	{
-		ItemId		itemid = PageGetItemId(page, offnum);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		Assert(!ItemIdIsDead(itemid));
-
-		if (offnum == minoff)
-		{
-			/*
-			 * No previous/base tuple for the data item -- use the data item
-			 * as base tuple of pending posting list
-			 */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-		else if (state->deduplicate &&
-				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
-				 _bt_dedup_save_htid(state, itup))
-		{
-			/*
-			 * Tuple is equal to base tuple of pending posting list.  Heap
-			 * TID(s) for itup have been saved in state.
-			 */
-		}
-		else
-		{
-			/*
-			 * Tuple is not equal to pending posting list tuple, or
-			 * _bt_dedup_save_htid() opted to not merge current item into
-			 * pending posting list for some other reason (e.g., adding more
-			 * TIDs would have caused posting list to exceed current
-			 * maxpostingsize).
-			 *
-			 * If state contains pending posting list with more than one item,
-			 * form new posting tuple and add it to our temp page (newpage).
-			 * Else add pending interval's base tuple to the temp page as-is.
-			 */
-			pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-			if (singlevalstrat)
-			{
-				/*
-				 * Single value strategy's extra steps.
-				 *
-				 * Lower maxpostingsize for sixth and final large posting list
-				 * tuple at the point where 5 maxpostingsize-capped tuples
-				 * have either been formed or observed.
-				 *
-				 * When a sixth maxpostingsize-capped item is formed/observed,
-				 * stop merging together tuples altogether.  The few tuples
-				 * that remain at the end of the page won't be merged together
-				 * at all (at least not until after a future page split takes
-				 * place, when this page's newly allocated right sibling page
-				 * gets its first deduplication pass).
-				 */
-				if (state->nmaxitems == 5)
-					_bt_singleval_fillfactor(page, state, newitemsz);
-				else if (state->nmaxitems == 6)
-				{
-					state->deduplicate = false;
-					singlevalstrat = false; /* won't be back here */
-				}
-			}
-
-			/* itup starts new pending posting list */
-			_bt_dedup_start_pending(state, itup, offnum);
-		}
-	}
-
-	/* Handle the last item */
-	pagesaving += _bt_dedup_finish_pending(newpage, state);
-
-	/*
-	 * If no items suitable for deduplication were found, newpage must be
-	 * exactly the same as the original page, so just return from function.
-	 *
-	 * We could determine whether or not to proceed on the basis the space
-	 * savings being sufficient to avoid an immediate page split instead.  We
-	 * don't do that because there is some small value in nbtsplitloc.c always
-	 * operating against a page that is fully deduplicated (apart from
-	 * newitem).  Besides, most of the cost has already been paid.
-	 */
-	if (state->nintervals == 0)
-	{
-		/* cannot leak memory here */
-		pfree(newpage);
-		pfree(state->htids);
-		pfree(state);
-		return;
-	}
-
-	/*
-	 * By here, it's clear that deduplication will definitely go ahead.
-	 *
-	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
-	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
-	 * But keep things tidy.
-	 */
-	if (P_HAS_GARBAGE(opaque))
-	{
-		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
-
-		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
-	}
-
-	START_CRIT_SECTION();
-
-	PageRestoreTempPage(newpage, page);
-	MarkBufferDirty(buf);
-
-	/* XLOG stuff */
-	if (RelationNeedsWAL(rel))
-	{
-		XLogRecPtr	recptr;
-		xl_btree_dedup xlrec_dedup;
-
-		xlrec_dedup.nintervals = state->nintervals;
-
-		XLogBeginInsert();
-		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
-
-		/*
-		 * The intervals array is not in the buffer, but pretend that it is.
-		 * When XLogInsert stores the whole buffer, the array need not be
-		 * stored too.
-		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
-							state->nintervals * sizeof(BTDedupInterval));
-
-		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
-
-		PageSetLSN(page, recptr);
-	}
-
-	END_CRIT_SECTION();
-
-	/* Local space accounting should agree with page accounting */
-	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
-
-	/* cannot leak memory here */
-	pfree(state->htids);
-	pfree(state);
-}
+#include "nbtdedup_spec.c"
 
 /*
  * Perform bottom-up index deletion pass.
@@ -752,55 +505,6 @@ _bt_bottomupdel_finish_pending(Page page, BTDedupState state,
 	state->phystupsize = 0;
 }
 
-/*
- * Determine if page non-pivot tuples (data items) are all duplicates of the
- * same value -- if they are, deduplication's "single value" strategy should
- * be applied.  The general goal of this strategy is to ensure that
- * nbtsplitloc.c (which uses its own single value strategy) will find a useful
- * split point as further duplicates are inserted, and successive rightmost
- * page splits occur among pages that store the same duplicate value.  When
- * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
- * just like it would if deduplication were disabled.
- *
- * We expect that affected workloads will require _several_ single value
- * strategy deduplication passes (over a page that only stores duplicates)
- * before the page is finally split.  The first deduplication pass should only
- * find regular non-pivot tuples.  Later deduplication passes will find
- * existing maxpostingsize-capped posting list tuples, which must be skipped
- * over.  The penultimate pass is generally the first pass that actually
- * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
- * few untouched non-pivot tuples.  The final deduplication pass won't free
- * any space -- it will skip over everything without merging anything (it
- * retraces the steps of the penultimate pass).
- *
- * Fortunately, having several passes isn't too expensive.  Each pass (after
- * the first pass) won't spend many cycles on the large posting list tuples
- * left by previous passes.  Each pass will find a large contiguous group of
- * smaller duplicate tuples to merge together at the end of the page.
- */
-static bool
-_bt_do_singleval(Relation rel, Page page, BTDedupState state,
-				 OffsetNumber minoff, IndexTuple newitem)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	ItemId		itemid;
-	IndexTuple	itup;
-
-	itemid = PageGetItemId(page, minoff);
-	itup = (IndexTuple) PageGetItem(page, itemid);
-
-	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-	{
-		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
-		itup = (IndexTuple) PageGetItem(page, itemid);
-
-		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
-			return true;
-	}
-
-	return false;
-}
-
 /*
  * Lower maxpostingsize when using "single value" strategy, to avoid a sixth
  * and final maxpostingsize-capped tuple.  The sixth and final posting list
diff --git a/src/backend/access/nbtree/nbtdedup_spec.c b/src/backend/access/nbtree/nbtdedup_spec.c
new file mode 100644
index 0000000000..056cf9908b
--- /dev/null
+++ b/src/backend/access/nbtree/nbtdedup_spec.c
@@ -0,0 +1,315 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtdedup_spec.c
+ *	  Index shape-specialized functions for nbtdedup.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtdedup_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static bool _bt_do_singleval(Relation rel, Page page, BTDedupState state,
+							 OffsetNumber minoff, IndexTuple newitem);
+
+/*
+ * Perform a deduplication pass.
+ *
+ * The general approach taken here is to perform as much deduplication as
+ * possible to free as much space as possible.  Note, however, that "single
+ * value" strategy is used for !bottomupdedup callers when the page is full of
+ * tuples of a single value.  Deduplication passes that apply the strategy
+ * will leave behind a few untouched tuples at the end of the page, preparing
+ * the page for an anticipated page split that uses nbtsplitloc.c's own single
+ * value strategy.  Our high level goal is to delay merging the untouched
+ * tuples until after the page splits.
+ *
+ * When a call to _bt_bottomupdel_pass() just took place (and failed), our
+ * high level goal is to prevent a page split entirely by buying more time.
+ * We still hope that a page split can be avoided altogether.  That's why
+ * single value strategy is not even considered for bottomupdedup callers.
+ *
+ * The page will have to be split if we cannot successfully free at least
+ * newitemsz (we also need space for newitem's line pointer, which isn't
+ * included in caller's newitemsz).
+ *
+ * Note: Caller should have already deleted all existing items with their
+ * LP_DEAD bits set.
+ */
+void
+_bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
+			   bool bottomupdedup)
+{
+	OffsetNumber offnum,
+				minoff,
+				maxoff;
+	Page		page = BufferGetPage(buf);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	Page		newpage;
+	BTDedupState state;
+	Size		pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
+	bool		singlevalstrat = false;
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+
+	/* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
+	newitemsz += sizeof(ItemIdData);
+
+	/*
+	 * Initialize deduplication state.
+	 *
+	 * It would be possible for maxpostingsize (limit on posting list tuple
+	 * size) to be set to one third of the page.  However, it seems like a
+	 * good idea to limit the size of posting lists to one sixth of a page.
+	 * That ought to leave us with a good split point when pages full of
+	 * duplicates can be split several times.
+	 */
+	state = (BTDedupState) palloc(sizeof(BTDedupStateData));
+	state->deduplicate = true;
+	state->nmaxitems = 0;
+	state->maxpostingsize = Min(BTMaxItemSize(page) / 2, INDEX_SIZE_MASK);
+	/* Metadata about base tuple of current pending posting list */
+	state->base = NULL;
+	state->baseoff = InvalidOffsetNumber;
+	state->basetupsize = 0;
+	/* Metadata about current pending posting list TIDs */
+	state->htids = palloc(state->maxpostingsize);
+	state->nhtids = 0;
+	state->nitems = 0;
+	/* Size of all physical tuples to be replaced by pending posting list */
+	state->phystupsize = 0;
+	/* nintervals should be initialized to zero */
+	state->nintervals = 0;
+
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * Consider applying "single value" strategy, though only if the page
+	 * seems likely to be split in the near future
+	 */
+	if (!bottomupdedup)
+		singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
+
+	/*
+	 * Deduplicate items from page, and write them to newpage.
+	 *
+	 * Copy the original page's LSN into newpage copy.  This will become the
+	 * updated version of the page.  We need this because XLogInsert will
+	 * examine the LSN and possibly dump it in a page image.
+	 */
+	newpage = PageGetTempPageCopySpecial(page);
+	PageSetLSN(newpage, PageGetLSN(page));
+
+	/* Copy high key, if any */
+	if (!P_RIGHTMOST(opaque))
+	{
+		ItemId		hitemid = PageGetItemId(page, P_HIKEY);
+		Size		hitemsz = ItemIdGetLength(hitemid);
+		IndexTuple	hitem = (IndexTuple) PageGetItem(page, hitemid);
+
+		if (PageAddItem(newpage, (Item) hitem, hitemsz, P_HIKEY,
+						false, false) == InvalidOffsetNumber)
+			elog(ERROR, "deduplication failed to add highkey");
+	}
+
+	for (offnum = minoff;
+		 offnum <= maxoff;
+		 offnum = OffsetNumberNext(offnum))
+	{
+		ItemId		itemid = PageGetItemId(page, offnum);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		Assert(!ItemIdIsDead(itemid));
+
+		if (offnum == minoff)
+		{
+			/*
+			 * No previous/base tuple for the data item -- use the data item
+			 * as base tuple of pending posting list
+			 */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+		else if (state->deduplicate &&
+				 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
+				 _bt_dedup_save_htid(state, itup))
+		{
+			/*
+			 * Tuple is equal to base tuple of pending posting list.  Heap
+			 * TID(s) for itup have been saved in state.
+			 */
+		}
+		else
+		{
+			/*
+			 * Tuple is not equal to pending posting list tuple, or
+			 * _bt_dedup_save_htid() opted to not merge current item into
+			 * pending posting list for some other reason (e.g., adding more
+			 * TIDs would have caused posting list to exceed current
+			 * maxpostingsize).
+			 *
+			 * If state contains pending posting list with more than one item,
+			 * form new posting tuple and add it to our temp page (newpage).
+			 * Else add pending interval's base tuple to the temp page as-is.
+			 */
+			pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+			if (singlevalstrat)
+			{
+				/*
+				 * Single value strategy's extra steps.
+				 *
+				 * Lower maxpostingsize for sixth and final large posting list
+				 * tuple at the point where 5 maxpostingsize-capped tuples
+				 * have either been formed or observed.
+				 *
+				 * When a sixth maxpostingsize-capped item is formed/observed,
+				 * stop merging together tuples altogether.  The few tuples
+				 * that remain at the end of the page won't be merged together
+				 * at all (at least not until after a future page split takes
+				 * place, when this page's newly allocated right sibling page
+				 * gets its first deduplication pass).
+				 */
+				if (state->nmaxitems == 5)
+					_bt_singleval_fillfactor(page, state, newitemsz);
+				else if (state->nmaxitems == 6)
+				{
+					state->deduplicate = false;
+					singlevalstrat = false; /* won't be back here */
+				}
+			}
+
+			/* itup starts new pending posting list */
+			_bt_dedup_start_pending(state, itup, offnum);
+		}
+	}
+
+	/* Handle the last item */
+	pagesaving += _bt_dedup_finish_pending(newpage, state);
+
+	/*
+	 * If no items suitable for deduplication were found, newpage must be
+	 * exactly the same as the original page, so just return from function.
+	 *
+	 * We could determine whether or not to proceed on the basis the space
+	 * savings being sufficient to avoid an immediate page split instead.  We
+	 * don't do that because there is some small value in nbtsplitloc.c always
+	 * operating against a page that is fully deduplicated (apart from
+	 * newitem).  Besides, most of the cost has already been paid.
+	 */
+	if (state->nintervals == 0)
+	{
+		/* cannot leak memory here */
+		pfree(newpage);
+		pfree(state->htids);
+		pfree(state);
+		return;
+	}
+
+	/*
+	 * By here, it's clear that deduplication will definitely go ahead.
+	 *
+	 * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
+	 * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
+	 * But keep things tidy.
+	 */
+	if (P_HAS_GARBAGE(opaque))
+	{
+		BTPageOpaque nopaque = BTPageGetOpaque(newpage);
+
+		nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
+	}
+
+	START_CRIT_SECTION();
+
+	PageRestoreTempPage(newpage, page);
+	MarkBufferDirty(buf);
+
+	/* XLOG stuff */
+	if (RelationNeedsWAL(rel))
+	{
+		XLogRecPtr	recptr;
+		xl_btree_dedup xlrec_dedup;
+
+		xlrec_dedup.nintervals = state->nintervals;
+
+		XLogBeginInsert();
+		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
+		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+
+		/*
+		 * The intervals array is not in the buffer, but pretend that it is.
+		 * When XLogInsert stores the whole buffer, the array need not be
+		 * stored too.
+		 */
+		XLogRegisterBufData(0, (char *) state->intervals,
+							state->nintervals * sizeof(BTDedupInterval));
+
+		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
+
+		PageSetLSN(page, recptr);
+	}
+
+	END_CRIT_SECTION();
+
+	/* Local space accounting should agree with page accounting */
+	Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
+
+	/* cannot leak memory here */
+	pfree(state->htids);
+	pfree(state);
+}
+
+/*
+ * Determine if page non-pivot tuples (data items) are all duplicates of the
+ * same value -- if they are, deduplication's "single value" strategy should
+ * be applied.  The general goal of this strategy is to ensure that
+ * nbtsplitloc.c (which uses its own single value strategy) will find a useful
+ * split point as further duplicates are inserted, and successive rightmost
+ * page splits occur among pages that store the same duplicate value.  When
+ * the page finally splits, it should end up BTREE_SINGLEVAL_FILLFACTOR% full,
+ * just like it would if deduplication were disabled.
+ *
+ * We expect that affected workloads will require _several_ single value
+ * strategy deduplication passes (over a page that only stores duplicates)
+ * before the page is finally split.  The first deduplication pass should only
+ * find regular non-pivot tuples.  Later deduplication passes will find
+ * existing maxpostingsize-capped posting list tuples, which must be skipped
+ * over.  The penultimate pass is generally the first pass that actually
+ * reaches _bt_singleval_fillfactor(), and so will deliberately leave behind a
+ * few untouched non-pivot tuples.  The final deduplication pass won't free
+ * any space -- it will skip over everything without merging anything (it
+ * retraces the steps of the penultimate pass).
+ *
+ * Fortunately, having several passes isn't too expensive.  Each pass (after
+ * the first pass) won't spend many cycles on the large posting list tuples
+ * left by previous passes.  Each pass will find a large contiguous group of
+ * smaller duplicate tuples to merge together at the end of the page.
+ */
+static bool
+_bt_do_singleval(Relation rel, Page page, BTDedupState state,
+				 OffsetNumber minoff, IndexTuple newitem)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	ItemId		itemid;
+	IndexTuple	itup;
+
+	itemid = PageGetItemId(page, minoff);
+	itup = (IndexTuple) PageGetItem(page, itemid);
+
+	if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+	{
+		itemid = PageGetItemId(page, PageGetMaxOffsetNumber(page));
+		itup = (IndexTuple) PageGetItem(page, itemid);
+
+		if (_bt_keep_natts_fast(rel, newitem, itup) > nkeyatts)
+			return true;
+	}
+
+	return false;
+}
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 7e8902e48c..013d473a74 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -30,18 +30,10 @@
 #define BTREE_FASTPATH_MIN_LEVEL	2
 
 
-static BTStack _bt_search_insert(Relation rel, Relation heaprel,
-								 BTInsertState insertstate);
 static TransactionId _bt_check_unique(Relation rel, BTInsertState insertstate,
 									  Relation heapRel,
 									  IndexUniqueCheck checkUnique, bool *is_unique,
 									  uint32 *speculativeToken);
-static OffsetNumber _bt_findinsertloc(Relation rel,
-									  BTInsertState insertstate,
-									  bool checkingunique,
-									  bool indexUnchanged,
-									  BTStack stack,
-									  Relation heapRel);
 static void _bt_stepright(Relation rel, Relation heaprel,
 						  BTInsertState insertstate, BTStack stack);
 static void _bt_insertonpg(Relation rel, Relation heaprel, BTScanInsert itup_key,
@@ -75,311 +67,7 @@ static BlockNumber *_bt_deadblocks(Page page, OffsetNumber *deletable,
 								   int *nblocks);
 static inline int _bt_blk_cmp(const void *arg1, const void *arg2);
 
-/*
- *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
- *
- *		This routine is called by the public interface routine, btinsert.
- *		By here, itup is filled in, including the TID.
- *
- *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
- *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
- *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
- *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
- *		don't actually insert.
- *
- *		indexUnchanged executor hint indicates if itup is from an
- *		UPDATE that didn't logically change the indexed value, but
- *		must nevertheless have a new entry to point to a successor
- *		version.
- *
- *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
- *		it must be true if the entry is known unique, else false.
- *		(In the current implementation we'll also return true after a
- *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
- *		that's just a coding artifact.)
- */
-bool
-_bt_doinsert(Relation rel, IndexTuple itup,
-			 IndexUniqueCheck checkUnique, bool indexUnchanged,
-			 Relation heapRel)
-{
-	bool		is_unique = false;
-	BTInsertStateData insertstate;
-	BTScanInsert itup_key;
-	BTStack		stack;
-	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
-
-	/* we need an insertion scan key to do our search, so build one */
-	itup_key = _bt_mkscankey(rel, itup);
-
-	if (checkingunique)
-	{
-		if (!itup_key->anynullkeys)
-		{
-			/* No (heapkeyspace) scantid until uniqueness established */
-			itup_key->scantid = NULL;
-		}
-		else
-		{
-			/*
-			 * Scan key for new tuple contains NULL key values.  Bypass
-			 * checkingunique steps.  They are unnecessary because core code
-			 * considers NULL unequal to every value, including NULL.
-			 *
-			 * This optimization avoids O(N^2) behavior within the
-			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
-			 * large number of "duplicates" with NULL key values.
-			 */
-			checkingunique = false;
-			/* Tuple is unique in the sense that core code cares about */
-			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
-			is_unique = true;
-		}
-	}
-
-	/*
-	 * Fill in the BTInsertState working area, to track the current page and
-	 * position within the page to insert on.
-	 *
-	 * Note that itemsz is passed down to lower level code that deals with
-	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
-	 * accounting code consistently considers the alignment overhead that we
-	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
-	 * already conservative about alignment, but we don't rely on that from
-	 * this distance.  Besides, preserving the "true" tuple size in index
-	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
-	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
-	 */
-	insertstate.itup = itup;
-	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
-	insertstate.itup_key = itup_key;
-	insertstate.bounds_valid = false;
-	insertstate.buf = InvalidBuffer;
-	insertstate.postingoff = 0;
-
-search:
-
-	/*
-	 * Find and lock the leaf page that the tuple should be added to by
-	 * searching from the root page.  insertstate.buf will hold a buffer that
-	 * is locked in exclusive mode afterwards.
-	 */
-	stack = _bt_search_insert(rel, heapRel, &insertstate);
-
-	/*
-	 * checkingunique inserts are not allowed to go ahead when two tuples with
-	 * equal key attribute values would be visible to new MVCC snapshots once
-	 * the xact commits.  Check for conflicts in the locked page/buffer (if
-	 * needed) here.
-	 *
-	 * It might be necessary to check a page to the right in _bt_check_unique,
-	 * though that should be very rare.  In practice the first page the value
-	 * could be on (with scantid omitted) is almost always also the only page
-	 * that a matching tuple might be found on.  This is due to the behavior
-	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
-	 * only be allowed to cross a page boundary when there is no candidate
-	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
-	 * the leaf page high key to determine that there will be no duplicates on
-	 * the right sibling without actually visiting it (it uses the high key in
-	 * cases where the new item happens to belong at the far right of the leaf
-	 * page).
-	 *
-	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
-	 * in the index; so it cannot defend against concurrent insertions of the
-	 * same key.  We protect against that by means of holding a write lock on
-	 * the first page the value could be on, with omitted/-inf value for the
-	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
-	 * the same key must acquire a write lock on the same page, so only one
-	 * would-be inserter can be making the check at one time.  Furthermore,
-	 * once we are past the check we hold write locks continuously until we
-	 * have performed our insertion, so no later inserter can fail to see our
-	 * insertion.  (This requires some care in _bt_findinsertloc.)
-	 *
-	 * If we must wait for another xact, we release the lock while waiting,
-	 * and then must perform a new search.
-	 *
-	 * For a partial uniqueness check, we don't wait for the other xact. Just
-	 * let the tuple in and return false for possibly non-unique, or true for
-	 * definitely unique.
-	 */
-	if (checkingunique)
-	{
-		TransactionId xwait;
-		uint32		speculativeToken;
-
-		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
-								 &is_unique, &speculativeToken);
-
-		if (unlikely(TransactionIdIsValid(xwait)))
-		{
-			/* Have to wait for the other guy ... */
-			_bt_relbuf(rel, insertstate.buf);
-			insertstate.buf = InvalidBuffer;
-
-			/*
-			 * If it's a speculative insertion, wait for it to finish (ie. to
-			 * go ahead with the insertion, or kill the tuple).  Otherwise
-			 * wait for the transaction to finish as usual.
-			 */
-			if (speculativeToken)
-				SpeculativeInsertionWait(xwait, speculativeToken);
-			else
-				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
-
-			/* start over... */
-			if (stack)
-				_bt_freestack(stack);
-			goto search;
-		}
-
-		/* Uniqueness is established -- restore heap tid as scantid */
-		if (itup_key->heapkeyspace)
-			itup_key->scantid = &itup->t_tid;
-	}
-
-	if (checkUnique != UNIQUE_CHECK_EXISTING)
-	{
-		OffsetNumber newitemoff;
-
-		/*
-		 * The only conflict predicate locking cares about for indexes is when
-		 * an index tuple insert conflicts with an existing lock.  We don't
-		 * know the actual page we're going to insert on for sure just yet in
-		 * checkingunique and !heapkeyspace cases, but it's okay to use the
-		 * first page the value could be on (with scantid omitted) instead.
-		 */
-		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
-
-		/*
-		 * Do the insertion.  Note that insertstate contains cached binary
-		 * search bounds established within _bt_check_unique when insertion is
-		 * checkingunique.
-		 */
-		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
-									   indexUnchanged, stack, heapRel);
-		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
-					   stack, itup, insertstate.itemsz, newitemoff,
-					   insertstate.postingoff, false);
-	}
-	else
-	{
-		/* just release the buffer */
-		_bt_relbuf(rel, insertstate.buf);
-	}
-
-	/* be tidy */
-	if (stack)
-		_bt_freestack(stack);
-	pfree(itup_key);
-
-	return is_unique;
-}
-
-/*
- *	_bt_search_insert() -- _bt_search() wrapper for inserts
- *
- * Search the tree for a particular scankey, or more precisely for the first
- * leaf page it could be on.  Try to make use of the fastpath optimization's
- * rightmost leaf page cache before actually searching the tree from the root
- * page, though.
- *
- * Return value is a stack of parent-page pointers (though see notes about
- * fastpath optimization and page splits below).  insertstate->buf is set to
- * the address of the leaf-page buffer, which is write-locked and pinned in
- * all cases (if necessary by creating a new empty root page for caller).
- *
- * The fastpath optimization avoids most of the work of searching the tree
- * repeatedly when a single backend inserts successive new tuples on the
- * rightmost leaf page of an index.  A backend cache of the rightmost leaf
- * page is maintained within _bt_insertonpg(), and used here.  The cache is
- * invalidated here when an insert of a non-pivot tuple must take place on a
- * non-rightmost leaf page.
- *
- * The optimization helps with indexes on an auto-incremented field.  It also
- * helps with indexes on datetime columns, as well as indexes with lots of
- * NULL values.  (NULLs usually get inserted in the rightmost page for single
- * column indexes, since they usually get treated as coming after everything
- * else in the key space.  Individual NULL tuples will generally be placed on
- * the rightmost leaf page due to the influence of the heap TID column.)
- *
- * Note that we avoid applying the optimization when there is insufficient
- * space on the rightmost page to fit caller's new item.  This is necessary
- * because we'll need to return a real descent stack when a page split is
- * expected (actually, caller can cope with a leaf page split that uses a NULL
- * stack, but that's very slow and so must be avoided).  Note also that the
- * fastpath optimization acquires the lock on the page conditionally as a way
- * of reducing extra contention when there are concurrent insertions into the
- * rightmost page (we give up if we'd have to wait for the lock).  We assume
- * that it isn't useful to apply the optimization when there is contention,
- * since each per-backend cache won't stay valid for long.
- */
-static BTStack
-_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
-{
-	Assert(insertstate->buf == InvalidBuffer);
-	Assert(!insertstate->bounds_valid);
-	Assert(insertstate->postingoff == 0);
-
-	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
-	{
-		/* Simulate a _bt_getbuf() call with conditional locking */
-		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
-		if (_bt_conditionallockbuf(rel, insertstate->buf))
-		{
-			Page		page;
-			BTPageOpaque opaque;
-
-			_bt_checkpage(rel, insertstate->buf);
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-
-			/*
-			 * Check if the page is still the rightmost leaf page and has
-			 * enough free space to accommodate the new tuple.  Also check
-			 * that the insertion scan key is strictly greater than the first
-			 * non-pivot tuple on the page.  (Note that we expect itup_key's
-			 * scantid to be unset when our caller is a checkingunique
-			 * inserter.)
-			 */
-			if (P_RIGHTMOST(opaque) &&
-				P_ISLEAF(opaque) &&
-				!P_IGNORE(opaque) &&
-				PageGetFreeSpace(page) > insertstate->itemsz &&
-				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
-				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
-			{
-				/*
-				 * Caller can use the fastpath optimization because cached
-				 * block is still rightmost leaf page, which can fit caller's
-				 * new tuple without splitting.  Keep block in local cache for
-				 * next insert, and have caller use NULL stack.
-				 *
-				 * Note that _bt_insert_parent() has an assertion that catches
-				 * leaf page splits that somehow follow from a fastpath insert
-				 * (it should only be passed a NULL stack when it must deal
-				 * with a concurrent root page split, and never because a NULL
-				 * stack was returned here).
-				 */
-				return NULL;
-			}
-
-			/* Page unsuitable for caller, drop lock and pin */
-			_bt_relbuf(rel, insertstate->buf);
-		}
-		else
-		{
-			/* Lock unavailable, drop pin */
-			ReleaseBuffer(insertstate->buf);
-		}
-
-		/* Forget block, since cache doesn't appear to be useful */
-		RelationSetTargetBlock(rel, InvalidBlockNumber);
-	}
-
-	/* Cannot use optimization -- descend tree, return proper descent stack */
-	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
-					  BT_WRITE);
-}
+#include "nbtinsert_spec.c"
 
 /*
  *	_bt_check_unique() -- Check for violation of unique index constraint
@@ -772,245 +460,6 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
 }
 
 
-/*
- *	_bt_findinsertloc() -- Finds an insert location for a tuple
- *
- *		On entry, insertstate buffer contains the page the new tuple belongs
- *		on.  It is exclusive-locked and pinned by the caller.
- *
- *		If 'checkingunique' is true, the buffer on entry is the first page
- *		that contains duplicates of the new key.  If there are duplicates on
- *		multiple pages, the correct insertion position might be some page to
- *		the right, rather than the first page.  In that case, this function
- *		moves right to the correct target page.
- *
- *		(In a !heapkeyspace index, there can be multiple pages with the same
- *		high key, where the new tuple could legitimately be placed on.  In
- *		that case, the caller passes the first page containing duplicates,
- *		just like when checkingunique=true.  If that page doesn't have enough
- *		room for the new tuple, this function moves right, trying to find a
- *		legal page that does.)
- *
- *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
- *		logically change the indexed value, but must nevertheless have a new
- *		entry to point to a successor version.  This hint from the executor
- *		will influence our behavior when the page might have to be split and
- *		we must consider our options.  Bottom-up index deletion can avoid
- *		pathological version-driven page splits, but we only want to go to the
- *		trouble of trying it when we already have moderate confidence that
- *		it's appropriate.  The hint should not significantly affect our
- *		behavior over time unless practically all inserts on to the leaf page
- *		get the hint.
- *
- *		On exit, insertstate buffer contains the chosen insertion page, and
- *		the offset within that page is returned.  If _bt_findinsertloc needed
- *		to move right, the lock and pin on the original page are released, and
- *		the new buffer is exclusively locked and pinned instead.
- *
- *		If insertstate contains cached binary search bounds, we will take
- *		advantage of them.  This avoids repeating comparisons that we made in
- *		_bt_check_unique() already.
- */
-static OffsetNumber
-_bt_findinsertloc(Relation rel,
-				  BTInsertState insertstate,
-				  bool checkingunique,
-				  bool indexUnchanged,
-				  BTStack stack,
-				  Relation heapRel)
-{
-	BTScanInsert itup_key = insertstate->itup_key;
-	Page		page = BufferGetPage(insertstate->buf);
-	BTPageOpaque opaque;
-	OffsetNumber newitemoff;
-
-	opaque = BTPageGetOpaque(page);
-
-	/* Check 1/3 of a page restriction */
-	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
-		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
-							 insertstate->itup);
-
-	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
-	Assert(!insertstate->bounds_valid || checkingunique);
-	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
-	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
-	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
-
-	if (itup_key->heapkeyspace)
-	{
-		/* Keep track of whether checkingunique duplicate seen */
-		bool		uniquedup = indexUnchanged;
-
-		/*
-		 * If we're inserting into a unique index, we may have to walk right
-		 * through leaf pages to find the one leaf page that we must insert on
-		 * to.
-		 *
-		 * This is needed for checkingunique callers because a scantid was not
-		 * used when we called _bt_search().  scantid can only be set after
-		 * _bt_check_unique() has checked for duplicates.  The buffer
-		 * initially stored in insertstate->buf has the page where the first
-		 * duplicate key might be found, which isn't always the page that new
-		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
-		 * could force us to insert on a sibling page, though that should be
-		 * very rare in practice.
-		 */
-		if (checkingunique)
-		{
-			if (insertstate->low < insertstate->stricthigh)
-			{
-				/* Encountered a duplicate in _bt_check_unique() */
-				Assert(insertstate->bounds_valid);
-				uniquedup = true;
-			}
-
-			for (;;)
-			{
-				/*
-				 * Does the new tuple belong on this page?
-				 *
-				 * The earlier _bt_check_unique() call may well have
-				 * established a strict upper bound on the offset for the new
-				 * item.  If it's not the last item of the page (i.e. if there
-				 * is at least one tuple on the page that goes after the tuple
-				 * we're inserting) then we know that the tuple belongs on
-				 * this page.  We can skip the high key check.
-				 */
-				if (insertstate->bounds_valid &&
-					insertstate->low <= insertstate->stricthigh &&
-					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-					break;
-
-				/* Test '<=', not '!=', since scantid is set now */
-				if (P_RIGHTMOST(opaque) ||
-					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
-					break;
-
-				_bt_stepright(rel, heapRel, insertstate, stack);
-				/* Update local state after stepping right */
-				page = BufferGetPage(insertstate->buf);
-				opaque = BTPageGetOpaque(page);
-				/* Assume duplicates (if checkingunique) */
-				uniquedup = true;
-			}
-		}
-
-		/*
-		 * If the target page cannot fit newitem, try to avoid splitting the
-		 * page on insert by performing deletion or deduplication now
-		 */
-		if (PageGetFreeSpace(page) < insertstate->itemsz)
-			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
-										 checkingunique, uniquedup,
-										 indexUnchanged);
-	}
-	else
-	{
-		/*----------
-		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
-		 * is the first page that we could insert the new tuple to, but there
-		 * may be other pages to the right that we could opt to use instead.
-		 *
-		 * If the new key is equal to one or more existing keys, we can
-		 * legitimately place it anywhere in the series of equal keys.  In
-		 * fact, if the new key is equal to the page's "high key" we can place
-		 * it on the next page.  If it is equal to the high key, and there's
-		 * not room to insert the new tuple on the current page without
-		 * splitting, then we move right hoping to find more free space and
-		 * avoid a split.
-		 *
-		 * Keep scanning right until we
-		 *		(a) find a page with enough free space,
-		 *		(b) reach the last page where the tuple can legally go, or
-		 *		(c) get tired of searching.
-		 * (c) is not flippant; it is important because if there are many
-		 * pages' worth of equal keys, it's better to split one of the early
-		 * pages than to scan all the way to the end of the run of equal keys
-		 * on every insert.  We implement "get tired" as a random choice,
-		 * since stopping after scanning a fixed number of pages wouldn't work
-		 * well (we'd never reach the right-hand side of previously split
-		 * pages).  The probability of moving right is set at 0.99, which may
-		 * seem too high to change the behavior much, but it does an excellent
-		 * job of preventing O(N^2) behavior with many equal keys.
-		 *----------
-		 */
-		while (PageGetFreeSpace(page) < insertstate->itemsz)
-		{
-			/*
-			 * Before considering moving right, see if we can obtain enough
-			 * space by erasing LP_DEAD items
-			 */
-			if (P_HAS_GARBAGE(opaque))
-			{
-				/* Perform simple deletion */
-				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-											 false, false, false);
-
-				if (PageGetFreeSpace(page) >= insertstate->itemsz)
-					break;		/* OK, now we have enough space */
-			}
-
-			/*
-			 * Nope, so check conditions (b) and (c) enumerated above
-			 *
-			 * The earlier _bt_check_unique() call may well have established a
-			 * strict upper bound on the offset for the new item.  If it's not
-			 * the last item of the page (i.e. if there is at least one tuple
-			 * on the page that's greater than the tuple we're inserting to)
-			 * then we know that the tuple belongs on this page.  We can skip
-			 * the high key check.
-			 */
-			if (insertstate->bounds_valid &&
-				insertstate->low <= insertstate->stricthigh &&
-				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
-				break;
-
-			if (P_RIGHTMOST(opaque) ||
-				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
-				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
-				break;
-
-			_bt_stepright(rel, heapRel, insertstate, stack);
-			/* Update local state after stepping right */
-			page = BufferGetPage(insertstate->buf);
-			opaque = BTPageGetOpaque(page);
-		}
-	}
-
-	/*
-	 * We should now be on the correct page.  Find the offset within the page
-	 * for the new tuple. (Possibly reusing earlier search bounds.)
-	 */
-	Assert(P_RIGHTMOST(opaque) ||
-		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
-
-	newitemoff = _bt_binsrch_insert(rel, insertstate);
-
-	if (insertstate->postingoff == -1)
-	{
-		/*
-		 * There is an overlapping posting list tuple with its LP_DEAD bit
-		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
-		 * performing a posting list split, so perform simple index tuple
-		 * deletion early.
-		 */
-		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
-									 false, false, false);
-
-		/*
-		 * Do new binary search.  New insert location cannot overlap with any
-		 * posting list now.
-		 */
-		Assert(!insertstate->bounds_valid);
-		insertstate->postingoff = 0;
-		newitemoff = _bt_binsrch_insert(rel, insertstate);
-		Assert(insertstate->postingoff == 0);
-	}
-
-	return newitemoff;
-}
-
 /*
  * Step right to next non-dead page, during insertion.
  *
diff --git a/src/backend/access/nbtree/nbtinsert_spec.c b/src/backend/access/nbtree/nbtinsert_spec.c
new file mode 100644
index 0000000000..b1f65ab1e6
--- /dev/null
+++ b/src/backend/access/nbtree/nbtinsert_spec.c
@@ -0,0 +1,573 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtinsert_spec.c
+ *	  Index shape-specialized functions for nbtinsert.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtinsert_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static BTStack _bt_search_insert(Relation rel, Relation heaprel,
+								 BTInsertState insertstate);
+static OffsetNumber _bt_findinsertloc(Relation rel,
+									  BTInsertState insertstate,
+									  bool checkingunique,
+									  bool indexUnchanged,
+									  BTStack stack,
+									  Relation heapRel);
+
+
+/*
+ *	_bt_doinsert() -- Handle insertion of a single index tuple in the tree.
+ *
+ *		This routine is called by the public interface routine, btinsert.
+ *		By here, itup is filled in, including the TID.
+ *
+ *		If checkUnique is UNIQUE_CHECK_NO or UNIQUE_CHECK_PARTIAL, this
+ *		will allow duplicates.  Otherwise (UNIQUE_CHECK_YES or
+ *		UNIQUE_CHECK_EXISTING) it will throw error for a duplicate.
+ *		For UNIQUE_CHECK_EXISTING we merely run the duplicate check, and
+ *		don't actually insert.
+ *
+ *		indexUnchanged executor hint indicates if itup is from an
+ *		UPDATE that didn't logically change the indexed value, but
+ *		must nevertheless have a new entry to point to a successor
+ *		version.
+ *
+ *		The result value is only significant for UNIQUE_CHECK_PARTIAL:
+ *		it must be true if the entry is known unique, else false.
+ *		(In the current implementation we'll also return true after a
+ *		successful UNIQUE_CHECK_YES or UNIQUE_CHECK_EXISTING call, but
+ *		that's just a coding artifact.)
+ */
+bool
+_bt_doinsert(Relation rel, IndexTuple itup,
+			 IndexUniqueCheck checkUnique, bool indexUnchanged,
+			 Relation heapRel)
+{
+	bool		is_unique = false;
+	BTInsertStateData insertstate;
+	BTScanInsert itup_key;
+	BTStack		stack;
+	bool		checkingunique = (checkUnique != UNIQUE_CHECK_NO);
+
+	/* we need an insertion scan key to do our search, so build one */
+	itup_key = _bt_mkscankey(rel, itup);
+
+	if (checkingunique)
+	{
+		if (!itup_key->anynullkeys)
+		{
+			/* No (heapkeyspace) scantid until uniqueness established */
+			itup_key->scantid = NULL;
+		}
+		else
+		{
+			/*
+			 * Scan key for new tuple contains NULL key values.  Bypass
+			 * checkingunique steps.  They are unnecessary because core code
+			 * considers NULL unequal to every value, including NULL.
+			 *
+			 * This optimization avoids O(N^2) behavior within the
+			 * _bt_findinsertloc() heapkeyspace path when a unique index has a
+			 * large number of "duplicates" with NULL key values.
+			 */
+			checkingunique = false;
+			/* Tuple is unique in the sense that core code cares about */
+			Assert(checkUnique != UNIQUE_CHECK_EXISTING);
+			is_unique = true;
+		}
+	}
+
+	/*
+	 * Fill in the BTInsertState working area, to track the current page and
+	 * position within the page to insert on.
+	 *
+	 * Note that itemsz is passed down to lower level code that deals with
+	 * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
+	 * accounting code consistently considers the alignment overhead that we
+	 * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
+	 * already conservative about alignment, but we don't rely on that from
+	 * this distance.  Besides, preserving the "true" tuple size in index
+	 * tuple headers for the benefit of nbtsplitloc.c might happen someday.
+	 * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
+	 */
+	insertstate.itup = itup;
+	insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
+	insertstate.itup_key = itup_key;
+	insertstate.bounds_valid = false;
+	insertstate.buf = InvalidBuffer;
+	insertstate.postingoff = 0;
+
+search:
+
+	/*
+	 * Find and lock the leaf page that the tuple should be added to by
+	 * searching from the root page.  insertstate.buf will hold a buffer that
+	 * is locked in exclusive mode afterwards.
+	 */
+	stack = _bt_search_insert(rel, heapRel, &insertstate);
+
+	/*
+	 * checkingunique inserts are not allowed to go ahead when two tuples with
+	 * equal key attribute values would be visible to new MVCC snapshots once
+	 * the xact commits.  Check for conflicts in the locked page/buffer (if
+	 * needed) here.
+	 *
+	 * It might be necessary to check a page to the right in _bt_check_unique,
+	 * though that should be very rare.  In practice the first page the value
+	 * could be on (with scantid omitted) is almost always also the only page
+	 * that a matching tuple might be found on.  This is due to the behavior
+	 * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
+	 * only be allowed to cross a page boundary when there is no candidate
+	 * leaf page split point that avoids it.  Also, _bt_check_unique can use
+	 * the leaf page high key to determine that there will be no duplicates on
+	 * the right sibling without actually visiting it (it uses the high key in
+	 * cases where the new item happens to belong at the far right of the leaf
+	 * page).
+	 *
+	 * NOTE: obviously, _bt_check_unique can only detect keys that are already
+	 * in the index; so it cannot defend against concurrent insertions of the
+	 * same key.  We protect against that by means of holding a write lock on
+	 * the first page the value could be on, with omitted/-inf value for the
+	 * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
+	 * the same key must acquire a write lock on the same page, so only one
+	 * would-be inserter can be making the check at one time.  Furthermore,
+	 * once we are past the check we hold write locks continuously until we
+	 * have performed our insertion, so no later inserter can fail to see our
+	 * insertion.  (This requires some care in _bt_findinsertloc.)
+	 *
+	 * If we must wait for another xact, we release the lock while waiting,
+	 * and then must perform a new search.
+	 *
+	 * For a partial uniqueness check, we don't wait for the other xact. Just
+	 * let the tuple in and return false for possibly non-unique, or true for
+	 * definitely unique.
+	 */
+	if (checkingunique)
+	{
+		TransactionId xwait;
+		uint32		speculativeToken;
+
+		xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
+								 &is_unique, &speculativeToken);
+
+		if (unlikely(TransactionIdIsValid(xwait)))
+		{
+			/* Have to wait for the other guy ... */
+			_bt_relbuf(rel, insertstate.buf);
+			insertstate.buf = InvalidBuffer;
+
+			/*
+			 * If it's a speculative insertion, wait for it to finish (ie. to
+			 * go ahead with the insertion, or kill the tuple).  Otherwise
+			 * wait for the transaction to finish as usual.
+			 */
+			if (speculativeToken)
+				SpeculativeInsertionWait(xwait, speculativeToken);
+			else
+				XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
+
+			/* start over... */
+			if (stack)
+				_bt_freestack(stack);
+			goto search;
+		}
+
+		/* Uniqueness is established -- restore heap tid as scantid */
+		if (itup_key->heapkeyspace)
+			itup_key->scantid = &itup->t_tid;
+	}
+
+	if (checkUnique != UNIQUE_CHECK_EXISTING)
+	{
+		OffsetNumber newitemoff;
+
+		/*
+		 * The only conflict predicate locking cares about for indexes is when
+		 * an index tuple insert conflicts with an existing lock.  We don't
+		 * know the actual page we're going to insert on for sure just yet in
+		 * checkingunique and !heapkeyspace cases, but it's okay to use the
+		 * first page the value could be on (with scantid omitted) instead.
+		 */
+		CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
+
+		/*
+		 * Do the insertion.  Note that insertstate contains cached binary
+		 * search bounds established within _bt_check_unique when insertion is
+		 * checkingunique.
+		 */
+		newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
+									   indexUnchanged, stack, heapRel);
+		_bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
+					   stack, itup, insertstate.itemsz, newitemoff,
+					   insertstate.postingoff, false);
+	}
+	else
+	{
+		/* just release the buffer */
+		_bt_relbuf(rel, insertstate.buf);
+	}
+
+	/* be tidy */
+	if (stack)
+		_bt_freestack(stack);
+	pfree(itup_key);
+
+	return is_unique;
+}
+
+/*
+ *	_bt_search_insert() -- _bt_search() wrapper for inserts
+ *
+ * Search the tree for a particular scankey, or more precisely for the first
+ * leaf page it could be on.  Try to make use of the fastpath optimization's
+ * rightmost leaf page cache before actually searching the tree from the root
+ * page, though.
+ *
+ * Return value is a stack of parent-page pointers (though see notes about
+ * fastpath optimization and page splits below).  insertstate->buf is set to
+ * the address of the leaf-page buffer, which is write-locked and pinned in
+ * all cases (if necessary by creating a new empty root page for caller).
+ *
+ * The fastpath optimization avoids most of the work of searching the tree
+ * repeatedly when a single backend inserts successive new tuples on the
+ * rightmost leaf page of an index.  A backend cache of the rightmost leaf
+ * page is maintained within _bt_insertonpg(), and used here.  The cache is
+ * invalidated here when an insert of a non-pivot tuple must take place on a
+ * non-rightmost leaf page.
+ *
+ * The optimization helps with indexes on an auto-incremented field.  It also
+ * helps with indexes on datetime columns, as well as indexes with lots of
+ * NULL values.  (NULLs usually get inserted in the rightmost page for single
+ * column indexes, since they usually get treated as coming after everything
+ * else in the key space.  Individual NULL tuples will generally be placed on
+ * the rightmost leaf page due to the influence of the heap TID column.)
+ *
+ * Note that we avoid applying the optimization when there is insufficient
+ * space on the rightmost page to fit caller's new item.  This is necessary
+ * because we'll need to return a real descent stack when a page split is
+ * expected (actually, caller can cope with a leaf page split that uses a NULL
+ * stack, but that's very slow and so must be avoided).  Note also that the
+ * fastpath optimization acquires the lock on the page conditionally as a way
+ * of reducing extra contention when there are concurrent insertions into the
+ * rightmost page (we give up if we'd have to wait for the lock).  We assume
+ * that it isn't useful to apply the optimization when there is contention,
+ * since each per-backend cache won't stay valid for long.
+ */
+static BTStack
+_bt_search_insert(Relation rel, Relation heaprel, BTInsertState insertstate)
+{
+	Assert(insertstate->buf == InvalidBuffer);
+	Assert(!insertstate->bounds_valid);
+	Assert(insertstate->postingoff == 0);
+
+	if (RelationGetTargetBlock(rel) != InvalidBlockNumber)
+	{
+		/* Simulate a _bt_getbuf() call with conditional locking */
+		insertstate->buf = ReadBuffer(rel, RelationGetTargetBlock(rel));
+		if (_bt_conditionallockbuf(rel, insertstate->buf))
+		{
+			Page		page;
+			BTPageOpaque opaque;
+
+			_bt_checkpage(rel, insertstate->buf);
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+
+			/*
+			 * Check if the page is still the rightmost leaf page and has
+			 * enough free space to accommodate the new tuple.  Also check
+			 * that the insertion scan key is strictly greater than the first
+			 * non-pivot tuple on the page.  (Note that we expect itup_key's
+			 * scantid to be unset when our caller is a checkingunique
+			 * inserter.)
+			 */
+			if (P_RIGHTMOST(opaque) &&
+				P_ISLEAF(opaque) &&
+				!P_IGNORE(opaque) &&
+				PageGetFreeSpace(page) > insertstate->itemsz &&
+				PageGetMaxOffsetNumber(page) >= P_HIKEY &&
+				_bt_compare(rel, insertstate->itup_key, page, P_HIKEY) > 0)
+			{
+				/*
+				 * Caller can use the fastpath optimization because cached
+				 * block is still rightmost leaf page, which can fit caller's
+				 * new tuple without splitting.  Keep block in local cache for
+				 * next insert, and have caller use NULL stack.
+				 *
+				 * Note that _bt_insert_parent() has an assertion that catches
+				 * leaf page splits that somehow follow from a fastpath insert
+				 * (it should only be passed a NULL stack when it must deal
+				 * with a concurrent root page split, and never because a NULL
+				 * stack was returned here).
+				 */
+				return NULL;
+			}
+
+			/* Page unsuitable for caller, drop lock and pin */
+			_bt_relbuf(rel, insertstate->buf);
+		}
+		else
+		{
+			/* Lock unavailable, drop pin */
+			ReleaseBuffer(insertstate->buf);
+		}
+
+		/* Forget block, since cache doesn't appear to be useful */
+		RelationSetTargetBlock(rel, InvalidBlockNumber);
+	}
+
+	/* Cannot use optimization -- descend tree, return proper descent stack */
+	return _bt_search(rel, heaprel, insertstate->itup_key, &insertstate->buf,
+					  BT_WRITE);
+}
+
+
+/*
+ *	_bt_findinsertloc() -- Finds an insert location for a tuple
+ *
+ *		On entry, insertstate buffer contains the page the new tuple belongs
+ *		on.  It is exclusive-locked and pinned by the caller.
+ *
+ *		If 'checkingunique' is true, the buffer on entry is the first page
+ *		that contains duplicates of the new key.  If there are duplicates on
+ *		multiple pages, the correct insertion position might be some page to
+ *		the right, rather than the first page.  In that case, this function
+ *		moves right to the correct target page.
+ *
+ *		(In a !heapkeyspace index, there can be multiple pages with the same
+ *		high key, where the new tuple could legitimately be placed on.  In
+ *		that case, the caller passes the first page containing duplicates,
+ *		just like when checkingunique=true.  If that page doesn't have enough
+ *		room for the new tuple, this function moves right, trying to find a
+ *		legal page that does.)
+ *
+ *		If 'indexUnchanged' is true, this is for an UPDATE that didn't
+ *		logically change the indexed value, but must nevertheless have a new
+ *		entry to point to a successor version.  This hint from the executor
+ *		will influence our behavior when the page might have to be split and
+ *		we must consider our options.  Bottom-up index deletion can avoid
+ *		pathological version-driven page splits, but we only want to go to the
+ *		trouble of trying it when we already have moderate confidence that
+ *		it's appropriate.  The hint should not significantly affect our
+ *		behavior over time unless practically all inserts on to the leaf page
+ *		get the hint.
+ *
+ *		On exit, insertstate buffer contains the chosen insertion page, and
+ *		the offset within that page is returned.  If _bt_findinsertloc needed
+ *		to move right, the lock and pin on the original page are released, and
+ *		the new buffer is exclusively locked and pinned instead.
+ *
+ *		If insertstate contains cached binary search bounds, we will take
+ *		advantage of them.  This avoids repeating comparisons that we made in
+ *		_bt_check_unique() already.
+ */
+static OffsetNumber
+_bt_findinsertloc(Relation rel,
+				  BTInsertState insertstate,
+				  bool checkingunique,
+				  bool indexUnchanged,
+				  BTStack stack,
+				  Relation heapRel)
+{
+	BTScanInsert itup_key = insertstate->itup_key;
+	Page		page = BufferGetPage(insertstate->buf);
+	BTPageOpaque opaque;
+	OffsetNumber newitemoff;
+
+	opaque = BTPageGetOpaque(page);
+
+	/* Check 1/3 of a page restriction */
+	if (unlikely(insertstate->itemsz > BTMaxItemSize(page)))
+		_bt_check_third_page(rel, heapRel, itup_key->heapkeyspace, page,
+							 insertstate->itup);
+
+	Assert(P_ISLEAF(opaque) && !P_INCOMPLETE_SPLIT(opaque));
+	Assert(!insertstate->bounds_valid || checkingunique);
+	Assert(!itup_key->heapkeyspace || itup_key->scantid != NULL);
+	Assert(itup_key->heapkeyspace || itup_key->scantid == NULL);
+	Assert(!itup_key->allequalimage || itup_key->heapkeyspace);
+
+	if (itup_key->heapkeyspace)
+	{
+		/* Keep track of whether checkingunique duplicate seen */
+		bool		uniquedup = indexUnchanged;
+
+		/*
+		 * If we're inserting into a unique index, we may have to walk right
+		 * through leaf pages to find the one leaf page that we must insert on
+		 * to.
+		 *
+		 * This is needed for checkingunique callers because a scantid was not
+		 * used when we called _bt_search().  scantid can only be set after
+		 * _bt_check_unique() has checked for duplicates.  The buffer
+		 * initially stored in insertstate->buf has the page where the first
+		 * duplicate key might be found, which isn't always the page that new
+		 * tuple belongs on.  The heap TID attribute for new tuple (scantid)
+		 * could force us to insert on a sibling page, though that should be
+		 * very rare in practice.
+		 */
+		if (checkingunique)
+		{
+			if (insertstate->low < insertstate->stricthigh)
+			{
+				/* Encountered a duplicate in _bt_check_unique() */
+				Assert(insertstate->bounds_valid);
+				uniquedup = true;
+			}
+
+			for (;;)
+			{
+				/*
+				 * Does the new tuple belong on this page?
+				 *
+				 * The earlier _bt_check_unique() call may well have
+				 * established a strict upper bound on the offset for the new
+				 * item.  If it's not the last item of the page (i.e. if there
+				 * is at least one tuple on the page that goes after the tuple
+				 * we're inserting) then we know that the tuple belongs on
+				 * this page.  We can skip the high key check.
+				 */
+				if (insertstate->bounds_valid &&
+					insertstate->low <= insertstate->stricthigh &&
+					insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+					break;
+
+				/* Test '<=', not '!=', since scantid is set now */
+				if (P_RIGHTMOST(opaque) ||
+					_bt_compare(rel, itup_key, page, P_HIKEY) <= 0)
+					break;
+
+				_bt_stepright(rel, heapRel, insertstate, stack);
+				/* Update local state after stepping right */
+				page = BufferGetPage(insertstate->buf);
+				opaque = BTPageGetOpaque(page);
+				/* Assume duplicates (if checkingunique) */
+				uniquedup = true;
+			}
+		}
+
+		/*
+		 * If the target page cannot fit newitem, try to avoid splitting the
+		 * page on insert by performing deletion or deduplication now
+		 */
+		if (PageGetFreeSpace(page) < insertstate->itemsz)
+			_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, false,
+										 checkingunique, uniquedup,
+										 indexUnchanged);
+	}
+	else
+	{
+		/*----------
+		 * This is a !heapkeyspace (version 2 or 3) index.  The current page
+		 * is the first page that we could insert the new tuple to, but there
+		 * may be other pages to the right that we could opt to use instead.
+		 *
+		 * If the new key is equal to one or more existing keys, we can
+		 * legitimately place it anywhere in the series of equal keys.  In
+		 * fact, if the new key is equal to the page's "high key" we can place
+		 * it on the next page.  If it is equal to the high key, and there's
+		 * not room to insert the new tuple on the current page without
+		 * splitting, then we move right hoping to find more free space and
+		 * avoid a split.
+		 *
+		 * Keep scanning right until we
+		 *		(a) find a page with enough free space,
+		 *		(b) reach the last page where the tuple can legally go, or
+		 *		(c) get tired of searching.
+		 * (c) is not flippant; it is important because if there are many
+		 * pages' worth of equal keys, it's better to split one of the early
+		 * pages than to scan all the way to the end of the run of equal keys
+		 * on every insert.  We implement "get tired" as a random choice,
+		 * since stopping after scanning a fixed number of pages wouldn't work
+		 * well (we'd never reach the right-hand side of previously split
+		 * pages).  The probability of moving right is set at 0.99, which may
+		 * seem too high to change the behavior much, but it does an excellent
+		 * job of preventing O(N^2) behavior with many equal keys.
+		 *----------
+		 */
+		while (PageGetFreeSpace(page) < insertstate->itemsz)
+		{
+			/*
+			 * Before considering moving right, see if we can obtain enough
+			 * space by erasing LP_DEAD items
+			 */
+			if (P_HAS_GARBAGE(opaque))
+			{
+				/* Perform simple deletion */
+				_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+											 false, false, false);
+
+				if (PageGetFreeSpace(page) >= insertstate->itemsz)
+					break;		/* OK, now we have enough space */
+			}
+
+			/*
+			 * Nope, so check conditions (b) and (c) enumerated above
+			 *
+			 * The earlier _bt_check_unique() call may well have established a
+			 * strict upper bound on the offset for the new item.  If it's not
+			 * the last item of the page (i.e. if there is at least one tuple
+			 * on the page that's greater than the tuple we're inserting to)
+			 * then we know that the tuple belongs on this page.  We can skip
+			 * the high key check.
+			 */
+			if (insertstate->bounds_valid &&
+				insertstate->low <= insertstate->stricthigh &&
+				insertstate->stricthigh <= PageGetMaxOffsetNumber(page))
+				break;
+
+			if (P_RIGHTMOST(opaque) ||
+				_bt_compare(rel, itup_key, page, P_HIKEY) != 0 ||
+				pg_prng_uint32(&pg_global_prng_state) <= (PG_UINT32_MAX / 100))
+				break;
+
+			_bt_stepright(rel, heapRel, insertstate, stack);
+			/* Update local state after stepping right */
+			page = BufferGetPage(insertstate->buf);
+			opaque = BTPageGetOpaque(page);
+		}
+	}
+
+	/*
+	 * We should now be on the correct page.  Find the offset within the page
+	 * for the new tuple. (Possibly reusing earlier search bounds.)
+	 */
+	Assert(P_RIGHTMOST(opaque) ||
+		   _bt_compare(rel, itup_key, page, P_HIKEY) <= 0);
+
+	newitemoff = _bt_binsrch_insert(rel, insertstate);
+
+	if (insertstate->postingoff == -1)
+	{
+		/*
+		 * There is an overlapping posting list tuple with its LP_DEAD bit
+		 * set.  We don't want to unnecessarily unset its LP_DEAD bit while
+		 * performing a posting list split, so perform simple index tuple
+		 * deletion early.
+		 */
+		_bt_delete_or_dedup_one_page(rel, heapRel, insertstate, true,
+									 false, false, false);
+
+		/*
+		 * Do new binary search.  New insert location cannot overlap with any
+		 * posting list now.
+		 */
+		Assert(!insertstate->bounds_valid);
+		insertstate->postingoff = 0;
+		newitemoff = _bt_binsrch_insert(rel, insertstate);
+		Assert(insertstate->postingoff == 0);
+	}
+
+	return newitemoff;
+}
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
index 41df1027d2..1e53964166 100644
--- a/src/backend/access/nbtree/nbtree.c
+++ b/src/backend/access/nbtree/nbtree.c
@@ -85,6 +85,7 @@ static BTVacuumPosting btreevacuumposting(BTVacState *vstate,
 										  OffsetNumber updatedoffset,
 										  int *nremaining);
 
+#include "nbtree_spec.c"
 
 /*
  * Btree handler function: return IndexAmRoutine with access method parameters
@@ -165,33 +166,6 @@ btbuildempty(Relation index)
 	smgr_bulk_finish(bulkstate);
 }
 
-/*
- *	btinsert() -- insert an index tuple into a btree.
- *
- *		Descend the tree recursively, find the appropriate location for our
- *		new tuple, and put it there.
- */
-bool
-btinsert(Relation rel, Datum *values, bool *isnull,
-		 ItemPointer ht_ctid, Relation heapRel,
-		 IndexUniqueCheck checkUnique,
-		 bool indexUnchanged,
-		 IndexInfo *indexInfo)
-{
-	bool		result;
-	IndexTuple	itup;
-
-	/* generate an index tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
-	itup->t_tid = *ht_ctid;
-
-	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
-
-	pfree(itup);
-
-	return result;
-}
-
 /*
  *	btgettuple() -- Get the next tuple in the scan.
  */
diff --git a/src/backend/access/nbtree/nbtree_spec.c b/src/backend/access/nbtree/nbtree_spec.c
new file mode 100644
index 0000000000..f6191303db
--- /dev/null
+++ b/src/backend/access/nbtree/nbtree_spec.c
@@ -0,0 +1,53 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtree_spec.c
+ *	  Index shape-specialized functions for nbtree.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtree_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+/*
+ * _bt_specialize() -- Specialize this index relation for its index key.
+ */
+void
+_bt_specialize(Relation rel)
+{
+	rel->rd_indam->aminsert = btinsert;
+}
+
+/*
+ *	btinsert() -- insert an index tuple into a btree.
+ *
+ *		Descend the tree recursively, find the appropriate location for our
+ *		new tuple, and put it there.
+ */
+bool
+btinsert(Relation rel, Datum *values, bool *isnull,
+		 ItemPointer ht_ctid, Relation heapRel,
+		 IndexUniqueCheck checkUnique,
+		 bool indexUnchanged,
+		 IndexInfo *indexInfo)
+{
+	bool		result;
+	IndexTuple	itup;
+
+	/* generate an index tuple */
+	itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
+	itup->t_tid = *ht_ctid;
+
+	result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
+
+	pfree(itup);
+
+	return result;
+}
diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index 63ee9ba225..e46ed8f377 100644
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -26,11 +26,8 @@
 
 
 static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
-static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
 static int	_bt_binsrch_posting(BTScanInsert key, Page page,
 								OffsetNumber offnum);
-static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
-						 OffsetNumber offnum, bool firstPage);
 static void _bt_saveitem(BTScanOpaque so, int itemIndex,
 						 OffsetNumber offnum, IndexTuple itup);
 static int	_bt_setuppostingitems(BTScanOpaque so, int itemIndex,
@@ -47,6 +44,7 @@ static Buffer _bt_walk_left(Relation rel, Buffer buf);
 static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
 static inline void _bt_initialize_more_data(BTScanOpaque so, ScanDirection dir);
 
+#include "nbtsearch_spec.c"
 
 /*
  *	_bt_drop_lock_and_maybe_pin()
@@ -71,519 +69,6 @@ _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp)
 	}
 }
 
-/*
- *	_bt_search() -- Search the tree for a particular scankey,
- *		or more precisely for the first leaf page it could be on.
- *
- * The passed scankey is an insertion-type scankey (see nbtree/README),
- * but it can omit the rightmost column(s) of the index.
- *
- * Return value is a stack of parent-page pointers (i.e. there is no entry for
- * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
- * which is locked and pinned.  No locks are held on the parent pages,
- * however!
- *
- * The returned buffer is locked according to access parameter.  Additionally,
- * access = BT_WRITE will allow an empty root page to be created and returned.
- * When access = BT_READ, an empty index will result in *bufP being set to
- * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
- * during the search will be finished.
- *
- * heaprel must be provided by callers that pass access = BT_WRITE, since we
- * might need to allocate a new root page for caller -- see _bt_allocbuf.
- */
-BTStack
-_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
-		   int access)
-{
-	BTStack		stack_in = NULL;
-	int			page_access = BT_READ;
-
-	/* heaprel must be set whenever _bt_allocbuf is reachable */
-	Assert(access == BT_READ || access == BT_WRITE);
-	Assert(access == BT_READ || heaprel != NULL);
-
-	/* Get the root page to start with */
-	*bufP = _bt_getroot(rel, heaprel, access);
-
-	/* If index is empty and access = BT_READ, no root page is created. */
-	if (!BufferIsValid(*bufP))
-		return (BTStack) NULL;
-
-	/* Loop iterates once per level descended in the tree */
-	for (;;)
-	{
-		Page		page;
-		BTPageOpaque opaque;
-		OffsetNumber offnum;
-		ItemId		itemid;
-		IndexTuple	itup;
-		BlockNumber child;
-		BTStack		new_stack;
-
-		/*
-		 * Race -- the page we just grabbed may have split since we read its
-		 * downlink in its parent page (or the metapage).  If it has, we may
-		 * need to move right to its new sibling.  Do that.
-		 *
-		 * In write-mode, allow _bt_moveright to finish any incomplete splits
-		 * along the way.  Strictly speaking, we'd only need to finish an
-		 * incomplete split on the leaf page we're about to insert to, not on
-		 * any of the upper levels (internal pages with incomplete splits are
-		 * also taken care of in _bt_getstackbuf).  But this is a good
-		 * opportunity to finish splits of internal pages too.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
-							  stack_in, page_access);
-
-		/* if this is a leaf page, we're done */
-		page = BufferGetPage(*bufP);
-		opaque = BTPageGetOpaque(page);
-		if (P_ISLEAF(opaque))
-			break;
-
-		/*
-		 * Find the appropriate pivot tuple on this page.  Its downlink points
-		 * to the child page that we're about to descend to.
-		 */
-		offnum = _bt_binsrch(rel, key, *bufP);
-		itemid = PageGetItemId(page, offnum);
-		itup = (IndexTuple) PageGetItem(page, itemid);
-		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
-		child = BTreeTupleGetDownLink(itup);
-
-		/*
-		 * We need to save the location of the pivot tuple we chose in a new
-		 * stack entry for this page/level.  If caller ends up splitting a
-		 * page one level down, it usually ends up inserting a new pivot
-		 * tuple/downlink immediately after the location recorded here.
-		 */
-		new_stack = (BTStack) palloc(sizeof(BTStackData));
-		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
-		new_stack->bts_offset = offnum;
-		new_stack->bts_parent = stack_in;
-
-		/*
-		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
-		 * we're on the level 1 and asked to lock leaf page in write mode,
-		 * then lock next page in write mode, because it must be a leaf.
-		 */
-		if (opaque->btpo_level == 1 && access == BT_WRITE)
-			page_access = BT_WRITE;
-
-		/* drop the read lock on the page, then acquire one on its child */
-		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
-
-		/* okay, all set to move down a level */
-		stack_in = new_stack;
-	}
-
-	/*
-	 * If we're asked to lock leaf in write mode, but didn't manage to, then
-	 * relock.  This should only happen when the root page is a leaf page (and
-	 * the only page in the index other than the metapage).
-	 */
-	if (access == BT_WRITE && page_access == BT_READ)
-	{
-		/* trade in our read lock for a write lock */
-		_bt_unlockbuf(rel, *bufP);
-		_bt_lockbuf(rel, *bufP, BT_WRITE);
-
-		/*
-		 * Race -- the leaf page may have split after we dropped the read lock
-		 * but before we acquired a write lock.  If it has, we may need to
-		 * move right to its new sibling.  Do that.
-		 */
-		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE);
-	}
-
-	return stack_in;
-}
-
-/*
- *	_bt_moveright() -- move right in the btree if necessary.
- *
- * When we follow a pointer to reach a page, it is possible that
- * the page has changed in the meanwhile.  If this happens, we're
- * guaranteed that the page has "split right" -- that is, that any
- * data that appeared on the page originally is either on the page
- * or strictly to the right of it.
- *
- * This routine decides whether or not we need to move right in the
- * tree by examining the high key entry on the page.  If that entry is
- * strictly less than the scankey, or <= the scankey in the
- * key.nextkey=true case, then we followed the wrong link and we need
- * to move right.
- *
- * The passed insertion-type scankey can omit the rightmost column(s) of the
- * index. (see nbtree/README)
- *
- * When key.nextkey is false (the usual case), we are looking for the first
- * item >= key.  When key.nextkey is true, we are looking for the first item
- * strictly greater than key.
- *
- * If forupdate is true, we will attempt to finish any incomplete splits
- * that we encounter.  This is required when locking a target page for an
- * insertion, because we don't allow inserting on a page before the split is
- * completed.  'heaprel' and 'stack' are only used if forupdate is true.
- *
- * On entry, we have the buffer pinned and a lock of the type specified by
- * 'access'.  If we move right, we release the buffer and lock and acquire
- * the same on the right sibling.  Return value is the buffer we stop at.
- */
-Buffer
-_bt_moveright(Relation rel,
-			  Relation heaprel,
-			  BTScanInsert key,
-			  Buffer buf,
-			  bool forupdate,
-			  BTStack stack,
-			  int access)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	int32		cmpval;
-
-	Assert(!forupdate || heaprel != NULL);
-
-	/*
-	 * When nextkey = false (normal case): if the scan key that brought us to
-	 * this page is > the high key stored on the page, then the page has split
-	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
-	 * have some duplicates to the right as well as the left, but that's
-	 * something that's only ever dealt with on the leaf level, after
-	 * _bt_search has found an initial leaf page.)
-	 *
-	 * When nextkey = true: move right if the scan key is >= page's high key.
-	 * (Note that key.scantid cannot be set in this case.)
-	 *
-	 * The page could even have split more than once, so scan as far as
-	 * needed.
-	 *
-	 * We also have to move right if we followed a link that brought us to a
-	 * dead page.
-	 */
-	cmpval = key->nextkey ? 0 : 1;
-
-	for (;;)
-	{
-		page = BufferGetPage(buf);
-		opaque = BTPageGetOpaque(page);
-
-		if (P_RIGHTMOST(opaque))
-			break;
-
-		/*
-		 * Finish any incomplete splits we encounter along the way.
-		 */
-		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
-		{
-			BlockNumber blkno = BufferGetBlockNumber(buf);
-
-			/* upgrade our lock if necessary */
-			if (access == BT_READ)
-			{
-				_bt_unlockbuf(rel, buf);
-				_bt_lockbuf(rel, buf, BT_WRITE);
-			}
-
-			if (P_INCOMPLETE_SPLIT(opaque))
-				_bt_finish_split(rel, heaprel, buf, stack);
-			else
-				_bt_relbuf(rel, buf);
-
-			/* re-acquire the lock in the right mode, and re-check */
-			buf = _bt_getbuf(rel, blkno, access);
-			continue;
-		}
-
-		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
-		{
-			/* step right one page */
-			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
-			continue;
-		}
-		else
-			break;
-	}
-
-	if (P_IGNORE(opaque))
-		elog(ERROR, "fell off the end of index \"%s\"",
-			 RelationGetRelationName(rel));
-
-	return buf;
-}
-
-/*
- *	_bt_binsrch() -- Do a binary search for a key on a particular page.
- *
- * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
- * of the last key < given scankey, or last key <= given scankey if nextkey
- * is true.  (Since _bt_compare treats the first data key of such a page as
- * minus infinity, there will be at least one key < scankey, so the result
- * always points at one of the keys on the page.)
- *
- * On a leaf page, _bt_binsrch() returns the final result of the initial
- * positioning process that started with _bt_first's call to _bt_search.
- * We're returning a non-pivot tuple offset, so things are a little different.
- * It is possible that we'll return an offset that's either past the last
- * non-pivot slot, or (in the case of a backward scan) before the first slot.
- *
- * This procedure is not responsible for walking right, it just examines
- * the given page.  _bt_binsrch() has no lock or refcount side effects
- * on the buffer.
- */
-static OffsetNumber
-_bt_binsrch(Relation rel,
-			BTScanInsert key,
-			Buffer buf)
-{
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* Requesting nextkey semantics while using scantid seems nonsensical */
-	Assert(!key->nextkey || key->scantid == NULL);
-	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
-	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
-
-	low = P_FIRSTDATAKEY(opaque);
-	high = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * If there are no keys on the page, return the first available slot. Note
-	 * this covers two cases: the page is really empty (no keys), or it
-	 * contains only a high key.  The latter case is possible after vacuuming.
-	 * This can never happen on an internal page, however, since they are
-	 * never empty (an internal page must have at least one child).
-	 */
-	if (unlikely(high < low))
-		return low;
-
-	/*
-	 * Binary search to find the first key on the page >= scan key, or first
-	 * key > scankey when nextkey is true.
-	 *
-	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
-	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
-	 *
-	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
-	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
-	 *
-	 * We can fall out when high == low.
-	 */
-	high++;						/* establish the loop invariant for high */
-
-	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-			high = mid;
-	}
-
-	/*
-	 * At this point we have high == low.
-	 *
-	 * On a leaf page we always return the first non-pivot tuple >= scan key
-	 * (resp. > scan key) for forward scan callers.  For backward scans, it's
-	 * always the _last_ non-pivot tuple < scan key (resp. <= scan key).
-	 */
-	if (P_ISLEAF(opaque))
-	{
-		/*
-		 * In the backward scan case we're supposed to locate the last
-		 * matching tuple on the leaf level -- not the first matching tuple
-		 * (the last tuple will be the first one returned by the scan).
-		 *
-		 * At this point we've located the first non-pivot tuple immediately
-		 * after the last matching tuple (which might just be maxoff + 1).
-		 * Compensate by stepping back.
-		 */
-		if (key->backward)
-			return OffsetNumberPrev(low);
-
-		return low;
-	}
-
-	/*
-	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
-	 * There must be one if _bt_compare() is playing by the rules.
-	 *
-	 * _bt_compare() will seldom see any exactly-matching pivot tuples, since
-	 * a truncated -inf heap TID is usually enough to prevent it altogether.
-	 * Even omitted scan key entries are treated as > truncated attributes.
-	 *
-	 * However, during backward scans _bt_compare() interprets omitted scan
-	 * key attributes as == corresponding truncated -inf attributes instead.
-	 * This works just like < would work here.  Under this scheme, < strategy
-	 * backward scans will always directly descend to the correct leaf page.
-	 * In particular, they will never incur an "extra" leaf page access with a
-	 * scan key that happens to contain the same prefix of values as some
-	 * pivot tuple's untruncated prefix.  VACUUM relies on this guarantee when
-	 * it uses a leaf page high key to "re-find" a page undergoing deletion.
-	 */
-	Assert(low > P_FIRSTDATAKEY(opaque));
-
-	return OffsetNumberPrev(low);
-}
-
-/*
- *
- *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
- *
- * Like _bt_binsrch(), but with support for caching the binary search
- * bounds.  Only used during insertion, and only on the leaf page that it
- * looks like caller will insert tuple on.  Exclusive-locked and pinned
- * leaf page is contained within insertstate.
- *
- * Caches the bounds fields in insertstate so that a subsequent call can
- * reuse the low and strict high bounds of original binary search.  Callers
- * that use these fields directly must be prepared for the case where low
- * and/or stricthigh are not on the same page (one or both exceed maxoff
- * for the page).  The case where there are no items on the page (high <
- * low) makes bounds invalid.
- *
- * Caller is responsible for invalidating bounds when it modifies the page
- * before calling here a second time, and for dealing with posting list
- * tuple matches (callers can use insertstate's postingoff field to
- * determine which existing heap TID will need to be replaced by a posting
- * list split).
- */
-OffsetNumber
-_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
-{
-	BTScanInsert key = insertstate->itup_key;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber low,
-				high,
-				stricthigh;
-	int32		result,
-				cmpval;
-
-	page = BufferGetPage(insertstate->buf);
-	opaque = BTPageGetOpaque(page);
-
-	Assert(P_ISLEAF(opaque));
-	Assert(!key->nextkey);
-	Assert(insertstate->postingoff == 0);
-
-	if (!insertstate->bounds_valid)
-	{
-		/* Start new binary search */
-		low = P_FIRSTDATAKEY(opaque);
-		high = PageGetMaxOffsetNumber(page);
-	}
-	else
-	{
-		/* Restore result of previous binary search against same page */
-		low = insertstate->low;
-		high = insertstate->stricthigh;
-	}
-
-	/* If there are no keys on the page, return the first available slot */
-	if (unlikely(high < low))
-	{
-		/* Caller can't reuse bounds */
-		insertstate->low = InvalidOffsetNumber;
-		insertstate->stricthigh = InvalidOffsetNumber;
-		insertstate->bounds_valid = false;
-		return low;
-	}
-
-	/*
-	 * Binary search to find the first key on the page >= scan key. (nextkey
-	 * is always false when inserting).
-	 *
-	 * The loop invariant is: all slots before 'low' are < scan key, all slots
-	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
-	 * maintained to save additional search effort for caller.
-	 *
-	 * We can fall out when high == low.
-	 */
-	if (!insertstate->bounds_valid)
-		high++;					/* establish the loop invariant for high */
-	stricthigh = high;			/* high initially strictly higher */
-
-	cmpval = 1;					/* !nextkey comparison value */
-
-	while (high > low)
-	{
-		OffsetNumber mid = low + ((high - low) / 2);
-
-		/* We have low <= mid < high, so mid points at a real slot */
-
-		result = _bt_compare(rel, key, page, mid);
-
-		if (result >= cmpval)
-			low = mid + 1;
-		else
-		{
-			high = mid;
-			if (result != 0)
-				stricthigh = high;
-		}
-
-		/*
-		 * If tuple at offset located by binary search is a posting list whose
-		 * TID range overlaps with caller's scantid, perform posting list
-		 * binary search to set postingoff for caller.  Caller must split the
-		 * posting list when postingoff is set.  This should happen
-		 * infrequently.
-		 */
-		if (unlikely(result == 0 && key->scantid != NULL))
-		{
-			/*
-			 * postingoff should never be set more than once per leaf page
-			 * binary search.  That would mean that there are duplicate table
-			 * TIDs in the index, which is never okay.  Check for that here.
-			 */
-			if (insertstate->postingoff != 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
-										 ItemPointerGetBlockNumber(key->scantid),
-										 ItemPointerGetOffsetNumber(key->scantid),
-										 low, stricthigh,
-										 BufferGetBlockNumber(insertstate->buf),
-										 RelationGetRelationName(rel))));
-
-			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
-		}
-	}
-
-	/*
-	 * On a leaf page, a binary search always returns the first key >= scan
-	 * key (at least in !nextkey case), which could be the last slot + 1. This
-	 * is also the lower bound of cached search.
-	 *
-	 * stricthigh may also be the last slot + 1, which prevents caller from
-	 * using bounds directly, but is still useful to us if we're called a
-	 * second time with cached bounds (cached low will be < stricthigh when
-	 * that happens).
-	 */
-	insertstate->low = low;
-	insertstate->stricthigh = stricthigh;
-	insertstate->bounds_valid = true;
-
-	return low;
-}
-
 /*----------
  *	_bt_binsrch_posting() -- posting list binary search.
  *
@@ -651,207 +136,6 @@ _bt_binsrch_posting(BTScanInsert key, Page page, OffsetNumber offnum)
 	return low;
 }
 
-/*----------
- *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
- *
- *	page/offnum: location of btree item to be compared to.
- *
- *		This routine returns:
- *			<0 if scankey < tuple at offnum;
- *			 0 if scankey == tuple at offnum;
- *			>0 if scankey > tuple at offnum.
- *
- * NULLs in the keys are treated as sortable values.  Therefore
- * "equality" does not necessarily mean that the item should be returned
- * to the caller as a matching key.  Similarly, an insertion scankey
- * with its scantid set is treated as equal to a posting tuple whose TID
- * range overlaps with their scantid.  There generally won't be a
- * matching TID in the posting tuple, which caller must handle
- * themselves (e.g., by splitting the posting list tuple).
- *
- * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
- * "minus infinity": this routine will always claim it is less than the
- * scankey.  The actual key value stored is explicitly truncated to 0
- * attributes (explicitly minus infinity) with version 3+ indexes, but
- * that isn't relied upon.  This allows us to implement the Lehman and
- * Yao convention that the first down-link pointer is before the first
- * key.  See backend/access/nbtree/README for details.
- *----------
- */
-int32
-_bt_compare(Relation rel,
-			BTScanInsert key,
-			Page page,
-			OffsetNumber offnum)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	BTPageOpaque opaque = BTPageGetOpaque(page);
-	IndexTuple	itup;
-	ItemPointer heapTid;
-	ScanKey		scankey;
-	int			ncmpkey;
-	int			ntupatts;
-	int32		result;
-
-	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
-	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
-	Assert(key->heapkeyspace || key->scantid == NULL);
-
-	/*
-	 * Force result ">" if target item is first data item on an internal page
-	 * --- see NOTE above.
-	 */
-	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
-		return 1;
-
-	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
-	ntupatts = BTreeTupleGetNAtts(itup, rel);
-
-	/*
-	 * The scan key is set up with the attribute number associated with each
-	 * term in the key.  It is important that, if the index is multi-key, the
-	 * scan contain the first k key attributes, and that they be in order.  If
-	 * you think about how multi-key ordering works, you'll understand why
-	 * this is.
-	 *
-	 * We don't test for violation of this condition here, however.  The
-	 * initial setup for the index scan had better have gotten it right (see
-	 * _bt_first).
-	 */
-
-	ncmpkey = Min(ntupatts, key->keysz);
-	Assert(key->heapkeyspace || ncmpkey == key->keysz);
-	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
-	scankey = key->scankeys;
-	for (int i = 1; i <= ncmpkey; i++)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
-
-		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
-		{
-			if (isNull)
-				result = 0;		/* NULL "=" NULL */
-			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = -1;	/* NULL "<" NOT_NULL */
-			else
-				result = 1;		/* NULL ">" NOT_NULL */
-		}
-		else if (isNull)		/* key is NOT_NULL and item is NULL */
-		{
-			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
-				result = 1;		/* NOT_NULL ">" NULL */
-			else
-				result = -1;	/* NOT_NULL "<" NULL */
-		}
-		else
-		{
-			/*
-			 * The sk_func needs to be passed the index value as left arg and
-			 * the sk_argument as right arg (they might be of different
-			 * types).  Since it is convenient for callers to think of
-			 * _bt_compare as comparing the scankey to the index item, we have
-			 * to flip the sign of the comparison result.  (Unless it's a DESC
-			 * column, in which case we *don't* flip the sign.)
-			 */
-			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-													 scankey->sk_collation,
-													 datum,
-													 scankey->sk_argument));
-
-			if (!(scankey->sk_flags & SK_BT_DESC))
-				INVERT_COMPARE_RESULT(result);
-		}
-
-		/* if the keys are unequal, return the difference */
-		if (result != 0)
-			return result;
-
-		scankey++;
-	}
-
-	/*
-	 * All non-truncated attributes (other than heap TID) were found to be
-	 * equal.  Treat truncated attributes as minus infinity when scankey has a
-	 * key attribute value that would otherwise be compared directly.
-	 *
-	 * Note: it doesn't matter if ntupatts includes non-key attributes;
-	 * scankey won't, so explicitly excluding non-key attributes isn't
-	 * necessary.
-	 */
-	if (key->keysz > ntupatts)
-		return 1;
-
-	/*
-	 * Use the heap TID attribute and scantid to try to break the tie.  The
-	 * rules are the same as any other key attribute -- only the
-	 * representation differs.
-	 */
-	heapTid = BTreeTupleGetHeapTID(itup);
-	if (key->scantid == NULL)
-	{
-		/*
-		 * Forward scans have a scankey that is considered greater than a
-		 * truncated pivot tuple if and when the scankey has equal values for
-		 * attributes up to and including the least significant untruncated
-		 * attribute in tuple.  Even attributes that were omitted from the
-		 * scan key are considered greater than -inf truncated attributes.
-		 * (See _bt_binsrch for an explanation of our backward scan behavior.)
-		 *
-		 * For example, if an index has the minimum two attributes (single
-		 * user key attribute, plus heap TID attribute), and a page's high key
-		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
-		 * will not descend to the page to the left.  The search will descend
-		 * right instead.  The truncated attribute in pivot tuple means that
-		 * all non-pivot tuples on the page to the left are strictly < 'foo',
-		 * so it isn't necessary to descend left.  In other words, search
-		 * doesn't have to descend left because it isn't interested in a match
-		 * that has a heap TID value of -inf.
-		 *
-		 * Note: the heap TID part of the test ensures that scankey is being
-		 * compared to a pivot tuple with one or more truncated -inf key
-		 * attributes.  The heap TID attribute is the last key attribute in
-		 * every index, of course, but other than that it isn't special.
-		 */
-		if (!key->backward && key->keysz == ntupatts && heapTid == NULL &&
-			key->heapkeyspace)
-			return 1;
-
-		/* All provided scankey arguments found to be equal */
-		return 0;
-	}
-
-	/*
-	 * Treat truncated heap TID as minus infinity, since scankey has a key
-	 * attribute value (scantid) that would otherwise be compared directly
-	 */
-	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
-	if (heapTid == NULL)
-		return 1;
-
-	/*
-	 * Scankey must be treated as equal to a posting list tuple if its scantid
-	 * value falls within the range of the posting list.  In all other cases
-	 * there can only be a single heap TID value, which is compared directly
-	 * with scantid.
-	 */
-	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
-	result = ItemPointerCompare(key->scantid, heapTid);
-	if (result <= 0 || !BTreeTupleIsPosting(itup))
-		return result;
-	else
-	{
-		result = ItemPointerCompare(key->scantid,
-									BTreeTupleGetMaxHeapTID(itup));
-		if (result > 0)
-			return 1;
-	}
-
-	return 0;
-}
-
 /*
  *	_bt_first() -- Find the first item in a scan.
  *
@@ -1491,358 +775,6 @@ _bt_next(IndexScanDesc scan, ScanDirection dir)
 	return true;
 }
 
-/*
- *	_bt_readpage() -- Load data from current index page into so->currPos
- *
- * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
- * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
- * they are updated as appropriate.  All other fields of so->currPos are
- * initialized from scratch here.
- *
- * We scan the current page starting at offnum and moving in the indicated
- * direction.  All items matching the scan keys are loaded into currPos.items.
- * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
- * that there can be no more matching tuples in the current scan direction.
- *
- * _bt_first caller passes us an offnum returned by _bt_binsrch, which might
- * be an out of bounds offnum such as "maxoff + 1" in certain corner cases.
- * _bt_checkkeys will stop the scan as soon as an equality qual fails (when
- * its scan key was marked required), so _bt_first _must_ pass us an offnum
- * exactly at the beginning of where equal tuples are to be found.  When we're
- * passed an offnum past the end of the page, we might still manage to stop
- * the scan on this page by calling _bt_checkkeys against the high key.
- *
- * In the case of a parallel scan, caller must have called _bt_parallel_seize
- * prior to calling this function; this function will invoke
- * _bt_parallel_release before returning.
- *
- * Returns true if any matching items found on the page, false if none.
- */
-static bool
-_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum,
-			 bool firstPage)
-{
-	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Page		page;
-	BTPageOpaque opaque;
-	OffsetNumber minoff;
-	OffsetNumber maxoff;
-	int			itemIndex;
-	bool		continuescan;
-	int			indnatts;
-	bool		continuescanPrechecked;
-	bool		haveFirstMatch = false;
-
-	/*
-	 * We must have the buffer pinned and locked, but the usual macro can't be
-	 * used here; this function is what makes it good for currPos.
-	 */
-	Assert(BufferIsValid(so->currPos.buf));
-
-	page = BufferGetPage(so->currPos.buf);
-	opaque = BTPageGetOpaque(page);
-
-	/* allow next page be processed by parallel worker */
-	if (scan->parallel_scan)
-	{
-		if (ScanDirectionIsForward(dir))
-			_bt_parallel_release(scan, opaque->btpo_next);
-		else
-			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
-	}
-
-	continuescan = true;		/* default assumption */
-	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
-	minoff = P_FIRSTDATAKEY(opaque);
-	maxoff = PageGetMaxOffsetNumber(page);
-
-	/*
-	 * We note the buffer's block number so that we can release the pin later.
-	 * This allows us to re-read the buffer if it is needed again for hinting.
-	 */
-	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
-
-	/*
-	 * We save the LSN of the page as we read it, so that we know whether it
-	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
-	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
-	 */
-	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
-
-	/*
-	 * we must save the page's right-link while scanning it; this tells us
-	 * where to step right to after we're done with these items.  There is no
-	 * corresponding need for the left-link, since splits always go right.
-	 */
-	so->currPos.nextPage = opaque->btpo_next;
-
-	/* initialize tuple workspace to empty */
-	so->currPos.nextTupleOffset = 0;
-
-	/*
-	 * Now that the current page has been made consistent, the macro should be
-	 * good.
-	 */
-	Assert(BTScanPosIsPinned(so->currPos));
-
-	/*
-	 * Prechecking the value of the continuescan flag for the last item on the
-	 * page (for backwards scan it will be the first item on a page).  If we
-	 * observe it to be true, then it should be true for all other items. This
-	 * allows us to do significant optimizations in the _bt_checkkeys()
-	 * function for all the items on the page.
-	 *
-	 * With the forward scan, we do this check for the last item on the page
-	 * instead of the high key.  It's relatively likely that the most
-	 * significant column in the high key will be different from the
-	 * corresponding value from the last item on the page.  So checking with
-	 * the last item on the page would give a more precise answer.
-	 *
-	 * We skip this for the first page in the scan to evade the possible
-	 * slowdown of the point queries.
-	 */
-	if (!firstPage && minoff < maxoff)
-	{
-		ItemId		iid;
-		IndexTuple	itup;
-
-		iid = PageGetItemId(page, ScanDirectionIsForward(dir) ? maxoff : minoff);
-		itup = (IndexTuple) PageGetItem(page, iid);
-
-		/*
-		 * Do the precheck.  Note that we pass the pointer to the
-		 * 'continuescanPrechecked' to the 'continuescan' argument. That will
-		 * set flag to true if all required keys are satisfied and false
-		 * otherwise.
-		 */
-		(void) _bt_checkkeys(scan, itup, indnatts, dir,
-							 &continuescanPrechecked, false, false);
-	}
-	else
-	{
-		continuescanPrechecked = false;
-	}
-
-	if (ScanDirectionIsForward(dir))
-	{
-		/* load items[] in ascending order */
-		itemIndex = 0;
-
-		offnum = Max(offnum, minoff);
-
-		while (offnum <= maxoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				offnum = OffsetNumberNext(offnum);
-				continue;
-			}
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-			Assert(!BTreeTupleIsPivot(itup));
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan,
-										 continuescanPrechecked,
-										 haveFirstMatch);
-
-			/*
-			 * If the result of prechecking required keys was true, then in
-			 * assert-enabled builds we also recheck that the _bt_checkkeys()
-			 * result is the same.
-			 */
-			Assert((!continuescanPrechecked && haveFirstMatch) ||
-				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
-												 &continuescan, false, false));
-			if (passes_quals)
-			{
-				/* tuple passes all scan key conditions */
-				haveFirstMatch = true;
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					_bt_saveitem(so, itemIndex, offnum, itup);
-					itemIndex++;
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID
-					 */
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					itemIndex++;
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-						itemIndex++;
-					}
-				}
-			}
-			/* When !continuescan, there can't be any more matches, so stop */
-			if (!continuescan)
-				break;
-
-			offnum = OffsetNumberNext(offnum);
-		}
-
-		/*
-		 * We don't need to visit page to the right when the high key
-		 * indicates that no more matches will be found there.
-		 *
-		 * Checking the high key like this works out more often than you might
-		 * think.  Leaf page splits pick a split point between the two most
-		 * dissimilar tuples (this is weighed against the need to evenly share
-		 * free space).  Leaf pages with high key attribute values that can
-		 * only appear on non-pivot tuples on the right sibling page are
-		 * common.
-		 */
-		if (continuescan && !P_RIGHTMOST(opaque))
-		{
-			ItemId		iid = PageGetItemId(page, P_HIKEY);
-			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
-			int			truncatt;
-
-			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
-			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan, false, false);
-		}
-
-		if (!continuescan)
-			so->currPos.moreRight = false;
-
-		Assert(itemIndex <= MaxTIDsPerBTreePage);
-		so->currPos.firstItem = 0;
-		so->currPos.lastItem = itemIndex - 1;
-		so->currPos.itemIndex = 0;
-	}
-	else
-	{
-		/* load items[] in descending order */
-		itemIndex = MaxTIDsPerBTreePage;
-
-		offnum = Min(offnum, maxoff);
-
-		while (offnum >= minoff)
-		{
-			ItemId		iid = PageGetItemId(page, offnum);
-			IndexTuple	itup;
-			bool		tuple_alive;
-			bool		passes_quals;
-
-			/*
-			 * If the scan specifies not to return killed tuples, then we
-			 * treat a killed tuple as not passing the qual.  Most of the
-			 * time, it's a win to not bother examining the tuple's index
-			 * keys, but just skip to the next tuple (previous, actually,
-			 * since we're scanning backwards).  However, if this is the first
-			 * tuple on the page, we do check the index keys, to prevent
-			 * uselessly advancing to the page to the left.  This is similar
-			 * to the high key optimization used by forward scans.
-			 */
-			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
-			{
-				Assert(offnum >= P_FIRSTDATAKEY(opaque));
-				if (offnum > P_FIRSTDATAKEY(opaque))
-				{
-					offnum = OffsetNumberPrev(offnum);
-					continue;
-				}
-
-				tuple_alive = false;
-			}
-			else
-				tuple_alive = true;
-
-			itup = (IndexTuple) PageGetItem(page, iid);
-			Assert(!BTreeTupleIsPivot(itup));
-
-			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
-										 &continuescan,
-										 continuescanPrechecked,
-										 haveFirstMatch);
-
-			/*
-			 * If the result of prechecking required keys was true, then in
-			 * assert-enabled builds we also recheck that the _bt_checkkeys()
-			 * result is the same.
-			 */
-			Assert((!continuescanPrechecked && !haveFirstMatch) ||
-				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
-												 &continuescan, false, false));
-			if (passes_quals && tuple_alive)
-			{
-				/* tuple passes all scan key conditions */
-				haveFirstMatch = true;
-				if (!BTreeTupleIsPosting(itup))
-				{
-					/* Remember it */
-					itemIndex--;
-					_bt_saveitem(so, itemIndex, offnum, itup);
-				}
-				else
-				{
-					int			tupleOffset;
-
-					/*
-					 * Set up state to return posting list, and remember first
-					 * TID.
-					 *
-					 * Note that we deliberately save/return items from
-					 * posting lists in ascending heap TID order for backwards
-					 * scans.  This allows _bt_killitems() to make a
-					 * consistent assumption about the order of items
-					 * associated with the same posting list tuple.
-					 */
-					itemIndex--;
-					tupleOffset =
-						_bt_setuppostingitems(so, itemIndex, offnum,
-											  BTreeTupleGetPostingN(itup, 0),
-											  itup);
-					/* Remember additional TIDs */
-					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
-					{
-						itemIndex--;
-						_bt_savepostingitem(so, itemIndex, offnum,
-											BTreeTupleGetPostingN(itup, i),
-											tupleOffset);
-					}
-				}
-			}
-			if (!continuescan)
-			{
-				/* there can't be any more matches, so stop */
-				so->currPos.moreLeft = false;
-				break;
-			}
-
-			offnum = OffsetNumberPrev(offnum);
-		}
-
-		Assert(itemIndex >= 0);
-		so->currPos.firstItem = itemIndex;
-		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
-		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
-	}
-
-	return (so->currPos.firstItem <= so->currPos.lastItem);
-}
-
 /* Save an index item into so->currPos.items[itemIndex] */
 static void
 _bt_saveitem(BTScanOpaque so, int itemIndex,
@@ -2051,13 +983,11 @@ static bool
 _bt_readnextpage(IndexScanDesc scan, BlockNumber blkno, ScanDirection dir)
 {
 	BTScanOpaque so = (BTScanOpaque) scan->opaque;
-	Relation	rel;
+	Relation	rel = scan->indexRelation;
 	Page		page;
 	BTPageOpaque opaque;
 	bool		status;
 
-	rel = scan->indexRelation;
-
 	if (ScanDirectionIsForward(dir))
 	{
 		for (;;)
diff --git a/src/backend/access/nbtree/nbtsearch_spec.c b/src/backend/access/nbtree/nbtsearch_spec.c
new file mode 100644
index 0000000000..a42aa4bb11
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsearch_spec.c
@@ -0,0 +1,1090 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsearch_spec.c
+ *	  Index shape-specialized functions for nbtsearch.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsearch_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static OffsetNumber _bt_binsrch(Relation rel, BTScanInsert key, Buffer buf);
+static Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
+							Buffer buf, bool forupdate, BTStack stack,
+							int access);
+static bool _bt_readpage(IndexScanDesc scan, ScanDirection dir,
+						 OffsetNumber offnum, bool firstPage);
+
+/*
+ *	_bt_search() -- Search the tree for a particular scankey,
+ *		or more precisely for the first leaf page it could be on.
+ *
+ * The passed scankey is an insertion-type scankey (see nbtree/README),
+ * but it can omit the rightmost column(s) of the index.
+ *
+ * Return value is a stack of parent-page pointers (i.e. there is no entry for
+ * the leaf level/page).  *bufP is set to the address of the leaf-page buffer,
+ * which is locked and pinned.  No locks are held on the parent pages,
+ * however!
+ *
+ * The returned buffer is locked according to access parameter.  Additionally,
+ * access = BT_WRITE will allow an empty root page to be created and returned.
+ * When access = BT_READ, an empty index will result in *bufP being set to
+ * InvalidBuffer.  Also, in BT_WRITE mode, any incomplete splits encountered
+ * during the search will be finished.
+ *
+ * heaprel must be provided by callers that pass access = BT_WRITE, since we
+ * might need to allocate a new root page for caller -- see _bt_allocbuf.
+ */
+BTStack
+_bt_search(Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP,
+		   int access)
+{
+	BTStack		stack_in = NULL;
+	int			page_access = BT_READ;
+
+	/* heaprel must be set whenever _bt_allocbuf is reachable */
+	Assert(access == BT_READ || access == BT_WRITE);
+	Assert(access == BT_READ || heaprel != NULL);
+
+	/* Get the root page to start with */
+	*bufP = _bt_getroot(rel, heaprel, access);
+
+	/* If index is empty and access = BT_READ, no root page is created. */
+	if (!BufferIsValid(*bufP))
+		return (BTStack) NULL;
+
+	/* Loop iterates once per level descended in the tree */
+	for (;;)
+	{
+		Page		page;
+		BTPageOpaque opaque;
+		OffsetNumber offnum;
+		ItemId		itemid;
+		IndexTuple	itup;
+		BlockNumber child;
+		BTStack		new_stack;
+
+		/*
+		 * Race -- the page we just grabbed may have split since we read its
+		 * downlink in its parent page (or the metapage).  If it has, we may
+		 * need to move right to its new sibling.  Do that.
+		 *
+		 * In write-mode, allow _bt_moveright to finish any incomplete splits
+		 * along the way.  Strictly speaking, we'd only need to finish an
+		 * incomplete split on the leaf page we're about to insert to, not on
+		 * any of the upper levels (internal pages with incomplete splits are
+		 * also taken care of in _bt_getstackbuf).  But this is a good
+		 * opportunity to finish splits of internal pages too.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
+							  stack_in, page_access);
+
+		/* if this is a leaf page, we're done */
+		page = BufferGetPage(*bufP);
+		opaque = BTPageGetOpaque(page);
+		if (P_ISLEAF(opaque))
+			break;
+
+		/*
+		 * Find the appropriate pivot tuple on this page.  Its downlink points
+		 * to the child page that we're about to descend to.
+		 */
+		offnum = _bt_binsrch(rel, key, *bufP);
+		itemid = PageGetItemId(page, offnum);
+		itup = (IndexTuple) PageGetItem(page, itemid);
+		Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
+		child = BTreeTupleGetDownLink(itup);
+
+		/*
+		 * We need to save the location of the pivot tuple we chose in a new
+		 * stack entry for this page/level.  If caller ends up splitting a
+		 * page one level down, it usually ends up inserting a new pivot
+		 * tuple/downlink immediately after the location recorded here.
+		 */
+		new_stack = (BTStack) palloc(sizeof(BTStackData));
+		new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
+		new_stack->bts_offset = offnum;
+		new_stack->bts_parent = stack_in;
+
+		/*
+		 * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
+		 * we're on the level 1 and asked to lock leaf page in write mode,
+		 * then lock next page in write mode, because it must be a leaf.
+		 */
+		if (opaque->btpo_level == 1 && access == BT_WRITE)
+			page_access = BT_WRITE;
+
+		/* drop the read lock on the page, then acquire one on its child */
+		*bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
+
+		/* okay, all set to move down a level */
+		stack_in = new_stack;
+	}
+
+	/*
+	 * If we're asked to lock leaf in write mode, but didn't manage to, then
+	 * relock.  This should only happen when the root page is a leaf page (and
+	 * the only page in the index other than the metapage).
+	 */
+	if (access == BT_WRITE && page_access == BT_READ)
+	{
+		/* trade in our read lock for a write lock */
+		_bt_unlockbuf(rel, *bufP);
+		_bt_lockbuf(rel, *bufP, BT_WRITE);
+
+		/*
+		 * Race -- the leaf page may have split after we dropped the read lock
+		 * but before we acquired a write lock.  If it has, we may need to
+		 * move right to its new sibling.  Do that.
+		 */
+		*bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE);
+	}
+
+	return stack_in;
+}
+
+/*
+ *	_bt_moveright() -- move right in the btree if necessary.
+ *
+ * When we follow a pointer to reach a page, it is possible that
+ * the page has changed in the meanwhile.  If this happens, we're
+ * guaranteed that the page has "split right" -- that is, that any
+ * data that appeared on the page originally is either on the page
+ * or strictly to the right of it.
+ *
+ * This routine decides whether or not we need to move right in the
+ * tree by examining the high key entry on the page.  If that entry is
+ * strictly less than the scankey, or <= the scankey in the
+ * key.nextkey=true case, then we followed the wrong link and we need
+ * to move right.
+ *
+ * The passed insertion-type scankey can omit the rightmost column(s) of the
+ * index. (see nbtree/README)
+ *
+ * When key.nextkey is false (the usual case), we are looking for the first
+ * item >= key.  When key.nextkey is true, we are looking for the first item
+ * strictly greater than key.
+ *
+ * If forupdate is true, we will attempt to finish any incomplete splits
+ * that we encounter.  This is required when locking a target page for an
+ * insertion, because we don't allow inserting on a page before the split is
+ * completed.  'heaprel' and 'stack' are only used if forupdate is true.
+ *
+ * On entry, we have the buffer pinned and a lock of the type specified by
+ * 'access'.  If we move right, we release the buffer and lock and acquire
+ * the same on the right sibling.  Return value is the buffer we stop at.
+ */
+Buffer
+_bt_moveright(Relation rel,
+			  Relation heaprel,
+			  BTScanInsert key,
+			  Buffer buf,
+			  bool forupdate,
+			  BTStack stack,
+			  int access)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	int32		cmpval;
+
+	Assert(!forupdate || heaprel != NULL);
+
+	/*
+	 * When nextkey = false (normal case): if the scan key that brought us to
+	 * this page is > the high key stored on the page, then the page has split
+	 * and we need to move right.  (pg_upgrade'd !heapkeyspace indexes could
+	 * have some duplicates to the right as well as the left, but that's
+	 * something that's only ever dealt with on the leaf level, after
+	 * _bt_search has found an initial leaf page.)
+	 *
+	 * When nextkey = true: move right if the scan key is >= page's high key.
+	 * (Note that key.scantid cannot be set in this case.)
+	 *
+	 * The page could even have split more than once, so scan as far as
+	 * needed.
+	 *
+	 * We also have to move right if we followed a link that brought us to a
+	 * dead page.
+	 */
+	cmpval = key->nextkey ? 0 : 1;
+
+	for (;;)
+	{
+		page = BufferGetPage(buf);
+		opaque = BTPageGetOpaque(page);
+
+		if (P_RIGHTMOST(opaque))
+			break;
+
+		/*
+		 * Finish any incomplete splits we encounter along the way.
+		 */
+		if (forupdate && P_INCOMPLETE_SPLIT(opaque))
+		{
+			BlockNumber blkno = BufferGetBlockNumber(buf);
+
+			/* upgrade our lock if necessary */
+			if (access == BT_READ)
+			{
+				_bt_unlockbuf(rel, buf);
+				_bt_lockbuf(rel, buf, BT_WRITE);
+			}
+
+			if (P_INCOMPLETE_SPLIT(opaque))
+				_bt_finish_split(rel, heaprel, buf, stack);
+			else
+				_bt_relbuf(rel, buf);
+
+			/* re-acquire the lock in the right mode, and re-check */
+			buf = _bt_getbuf(rel, blkno, access);
+			continue;
+		}
+
+		if (P_IGNORE(opaque) || _bt_compare(rel, key, page, P_HIKEY) >= cmpval)
+		{
+			/* step right one page */
+			buf = _bt_relandgetbuf(rel, buf, opaque->btpo_next, access);
+			continue;
+		}
+		else
+			break;
+	}
+
+	if (P_IGNORE(opaque))
+		elog(ERROR, "fell off the end of index \"%s\"",
+			 RelationGetRelationName(rel));
+
+	return buf;
+}
+
+/*
+ *	_bt_binsrch() -- Do a binary search for a key on a particular page.
+ *
+ * On an internal (non-leaf) page, _bt_binsrch() returns the OffsetNumber
+ * of the last key < given scankey, or last key <= given scankey if nextkey
+ * is true.  (Since _bt_compare treats the first data key of such a page as
+ * minus infinity, there will be at least one key < scankey, so the result
+ * always points at one of the keys on the page.)
+ *
+ * On a leaf page, _bt_binsrch() returns the final result of the initial
+ * positioning process that started with _bt_first's call to _bt_search.
+ * We're returning a non-pivot tuple offset, so things are a little different.
+ * It is possible that we'll return an offset that's either past the last
+ * non-pivot slot, or (in the case of a backward scan) before the first slot.
+ *
+ * This procedure is not responsible for walking right, it just examines
+ * the given page.  _bt_binsrch() has no lock or refcount side effects
+ * on the buffer.
+ */
+static OffsetNumber
+_bt_binsrch(Relation rel,
+			BTScanInsert key,
+			Buffer buf)
+{
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* Requesting nextkey semantics while using scantid seems nonsensical */
+	Assert(!key->nextkey || key->scantid == NULL);
+	/* scantid-set callers must use _bt_binsrch_insert() on leaf pages */
+	Assert(!P_ISLEAF(opaque) || key->scantid == NULL);
+
+	low = P_FIRSTDATAKEY(opaque);
+	high = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * If there are no keys on the page, return the first available slot. Note
+	 * this covers two cases: the page is really empty (no keys), or it
+	 * contains only a high key.  The latter case is possible after vacuuming.
+	 * This can never happen on an internal page, however, since they are
+	 * never empty (an internal page must have at least one child).
+	 */
+	if (unlikely(high < low))
+		return low;
+
+	/*
+	 * Binary search to find the first key on the page >= scan key, or first
+	 * key > scankey when nextkey is true.
+	 *
+	 * For nextkey=false (cmpval=1), the loop invariant is: all slots before
+	 * 'low' are < scan key, all slots at or after 'high' are >= scan key.
+	 *
+	 * For nextkey=true (cmpval=0), the loop invariant is: all slots before
+	 * 'low' are <= scan key, all slots at or after 'high' are > scan key.
+	 *
+	 * We can fall out when high == low.
+	 */
+	high++;						/* establish the loop invariant for high */
+
+	cmpval = key->nextkey ? 0 : 1;	/* select comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+			high = mid;
+	}
+
+	/*
+	 * At this point we have high == low.
+	 *
+	 * On a leaf page we always return the first non-pivot tuple >= scan key
+	 * (resp. > scan key) for forward scan callers.  For backward scans, it's
+	 * always the _last_ non-pivot tuple < scan key (resp. <= scan key).
+	 */
+	if (P_ISLEAF(opaque))
+	{
+		/*
+		 * In the backward scan case we're supposed to locate the last
+		 * matching tuple on the leaf level -- not the first matching tuple
+		 * (the last tuple will be the first one returned by the scan).
+		 *
+		 * At this point we've located the first non-pivot tuple immediately
+		 * after the last matching tuple (which might just be maxoff + 1).
+		 * Compensate by stepping back.
+		 */
+		if (key->backward)
+			return OffsetNumberPrev(low);
+
+		return low;
+	}
+
+	/*
+	 * On a non-leaf page, return the last key < scan key (resp. <= scan key).
+	 * There must be one if _bt_compare() is playing by the rules.
+	 *
+	 * _bt_compare() will seldom see any exactly-matching pivot tuples, since
+	 * a truncated -inf heap TID is usually enough to prevent it altogether.
+	 * Even omitted scan key entries are treated as > truncated attributes.
+	 *
+	 * However, during backward scans _bt_compare() interprets omitted scan
+	 * key attributes as == corresponding truncated -inf attributes instead.
+	 * This works just like < would work here.  Under this scheme, < strategy
+	 * backward scans will always directly descend to the correct leaf page.
+	 * In particular, they will never incur an "extra" leaf page access with a
+	 * scan key that happens to contain the same prefix of values as some
+	 * pivot tuple's untruncated prefix.  VACUUM relies on this guarantee when
+	 * it uses a leaf page high key to "re-find" a page undergoing deletion.
+	 */
+	Assert(low > P_FIRSTDATAKEY(opaque));
+
+	return OffsetNumberPrev(low);
+}
+
+/*
+ *
+ *	_bt_binsrch_insert() -- Cacheable, incremental leaf page binary search.
+ *
+ * Like _bt_binsrch(), but with support for caching the binary search
+ * bounds.  Only used during insertion, and only on the leaf page that it
+ * looks like caller will insert tuple on.  Exclusive-locked and pinned
+ * leaf page is contained within insertstate.
+ *
+ * Caches the bounds fields in insertstate so that a subsequent call can
+ * reuse the low and strict high bounds of original binary search.  Callers
+ * that use these fields directly must be prepared for the case where low
+ * and/or stricthigh are not on the same page (one or both exceed maxoff
+ * for the page).  The case where there are no items on the page (high <
+ * low) makes bounds invalid.
+ *
+ * Caller is responsible for invalidating bounds when it modifies the page
+ * before calling here a second time, and for dealing with posting list
+ * tuple matches (callers can use insertstate's postingoff field to
+ * determine which existing heap TID will need to be replaced by a posting
+ * list split).
+ */
+OffsetNumber
+_bt_binsrch_insert(Relation rel, BTInsertState insertstate)
+{
+	BTScanInsert key = insertstate->itup_key;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber low,
+				high,
+				stricthigh;
+	int32		result,
+				cmpval;
+
+	page = BufferGetPage(insertstate->buf);
+	opaque = BTPageGetOpaque(page);
+
+	Assert(P_ISLEAF(opaque));
+	Assert(!key->nextkey);
+	Assert(insertstate->postingoff == 0);
+
+	if (!insertstate->bounds_valid)
+	{
+		/* Start new binary search */
+		low = P_FIRSTDATAKEY(opaque);
+		high = PageGetMaxOffsetNumber(page);
+	}
+	else
+	{
+		/* Restore result of previous binary search against same page */
+		low = insertstate->low;
+		high = insertstate->stricthigh;
+	}
+
+	/* If there are no keys on the page, return the first available slot */
+	if (unlikely(high < low))
+	{
+		/* Caller can't reuse bounds */
+		insertstate->low = InvalidOffsetNumber;
+		insertstate->stricthigh = InvalidOffsetNumber;
+		insertstate->bounds_valid = false;
+		return low;
+	}
+
+	/*
+	 * Binary search to find the first key on the page >= scan key. (nextkey
+	 * is always false when inserting).
+	 *
+	 * The loop invariant is: all slots before 'low' are < scan key, all slots
+	 * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
+	 * maintained to save additional search effort for caller.
+	 *
+	 * We can fall out when high == low.
+	 */
+	if (!insertstate->bounds_valid)
+		high++;					/* establish the loop invariant for high */
+	stricthigh = high;			/* high initially strictly higher */
+
+	cmpval = 1;					/* !nextkey comparison value */
+
+	while (high > low)
+	{
+		OffsetNumber mid = low + ((high - low) / 2);
+
+		/* We have low <= mid < high, so mid points at a real slot */
+
+		result = _bt_compare(rel, key, page, mid);
+
+		if (result >= cmpval)
+			low = mid + 1;
+		else
+		{
+			high = mid;
+			if (result != 0)
+				stricthigh = high;
+		}
+
+		/*
+		 * If tuple at offset located by binary search is a posting list whose
+		 * TID range overlaps with caller's scantid, perform posting list
+		 * binary search to set postingoff for caller.  Caller must split the
+		 * posting list when postingoff is set.  This should happen
+		 * infrequently.
+		 */
+		if (unlikely(result == 0 && key->scantid != NULL))
+		{
+			/*
+			 * postingoff should never be set more than once per leaf page
+			 * binary search.  That would mean that there are duplicate table
+			 * TIDs in the index, which is never okay.  Check for that here.
+			 */
+			if (insertstate->postingoff != 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INDEX_CORRUPTED),
+						 errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
+										 ItemPointerGetBlockNumber(key->scantid),
+										 ItemPointerGetOffsetNumber(key->scantid),
+										 low, stricthigh,
+										 BufferGetBlockNumber(insertstate->buf),
+										 RelationGetRelationName(rel))));
+
+			insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
+		}
+	}
+
+	/*
+	 * On a leaf page, a binary search always returns the first key >= scan
+	 * key (at least in !nextkey case), which could be the last slot + 1. This
+	 * is also the lower bound of cached search.
+	 *
+	 * stricthigh may also be the last slot + 1, which prevents caller from
+	 * using bounds directly, but is still useful to us if we're called a
+	 * second time with cached bounds (cached low will be < stricthigh when
+	 * that happens).
+	 */
+	insertstate->low = low;
+	insertstate->stricthigh = stricthigh;
+	insertstate->bounds_valid = true;
+
+	return low;
+}
+
+/*----------
+ *	_bt_compare() -- Compare insertion-type scankey to tuple on a page.
+ *
+ *	page/offnum: location of btree item to be compared to.
+ *
+ *		This routine returns:
+ *			<0 if scankey < tuple at offnum;
+ *			 0 if scankey == tuple at offnum;
+ *			>0 if scankey > tuple at offnum.
+ *
+ * NULLs in the keys are treated as sortable values.  Therefore
+ * "equality" does not necessarily mean that the item should be returned
+ * to the caller as a matching key.  Similarly, an insertion scankey
+ * with its scantid set is treated as equal to a posting tuple whose TID
+ * range overlaps with their scantid.  There generally won't be a
+ * matching TID in the posting tuple, which caller must handle
+ * themselves (e.g., by splitting the posting list tuple).
+ *
+ * CRUCIAL NOTE: on a non-leaf page, the first data key is assumed to be
+ * "minus infinity": this routine will always claim it is less than the
+ * scankey.  The actual key value stored is explicitly truncated to 0
+ * attributes (explicitly minus infinity) with version 3+ indexes, but
+ * that isn't relied upon.  This allows us to implement the Lehman and
+ * Yao convention that the first down-link pointer is before the first
+ * key.  See backend/access/nbtree/README for details.
+ *----------
+ */
+int32
+_bt_compare(Relation rel,
+			BTScanInsert key,
+			Page page,
+			OffsetNumber offnum)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	BTPageOpaque opaque = BTPageGetOpaque(page);
+	IndexTuple	itup;
+	ItemPointer heapTid;
+	ScanKey		scankey;
+	int			ncmpkey;
+	int			ntupatts;
+	int32		result;
+
+	Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
+	Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
+	Assert(key->heapkeyspace || key->scantid == NULL);
+
+	/*
+	 * Force result ">" if target item is first data item on an internal page
+	 * --- see NOTE above.
+	 */
+	if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
+		return 1;
+
+	itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
+	ntupatts = BTreeTupleGetNAtts(itup, rel);
+
+	/*
+	 * The scan key is set up with the attribute number associated with each
+	 * term in the key.  It is important that, if the index is multi-key, the
+	 * scan contain the first k key attributes, and that they be in order.  If
+	 * you think about how multi-key ordering works, you'll understand why
+	 * this is.
+	 *
+	 * We don't test for violation of this condition here, however.  The
+	 * initial setup for the index scan had better have gotten it right (see
+	 * _bt_first).
+	 */
+
+	ncmpkey = Min(ntupatts, key->keysz);
+	Assert(key->heapkeyspace || ncmpkey == key->keysz);
+	Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
+	scankey = key->scankeys;
+	for (int i = 1; i <= ncmpkey; i++)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
+
+		if (scankey->sk_flags & SK_ISNULL)	/* key is NULL */
+		{
+			if (isNull)
+				result = 0;		/* NULL "=" NULL */
+			else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = -1;	/* NULL "<" NOT_NULL */
+			else
+				result = 1;		/* NULL ">" NOT_NULL */
+		}
+		else if (isNull)		/* key is NOT_NULL and item is NULL */
+		{
+			if (scankey->sk_flags & SK_BT_NULLS_FIRST)
+				result = 1;		/* NOT_NULL ">" NULL */
+			else
+				result = -1;	/* NOT_NULL "<" NULL */
+		}
+		else
+		{
+			/*
+			 * The sk_func needs to be passed the index value as left arg and
+			 * the sk_argument as right arg (they might be of different
+			 * types).  Since it is convenient for callers to think of
+			 * _bt_compare as comparing the scankey to the index item, we have
+			 * to flip the sign of the comparison result.  (Unless it's a DESC
+			 * column, in which case we *don't* flip the sign.)
+			 */
+			result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+													 scankey->sk_collation,
+													 datum,
+													 scankey->sk_argument));
+
+			if (!(scankey->sk_flags & SK_BT_DESC))
+				INVERT_COMPARE_RESULT(result);
+		}
+
+		/* if the keys are unequal, return the difference */
+		if (result != 0)
+			return result;
+
+		scankey++;
+	}
+
+	/*
+	 * All non-truncated attributes (other than heap TID) were found to be
+	 * equal.  Treat truncated attributes as minus infinity when scankey has a
+	 * key attribute value that would otherwise be compared directly.
+	 *
+	 * Note: it doesn't matter if ntupatts includes non-key attributes;
+	 * scankey won't, so explicitly excluding non-key attributes isn't
+	 * necessary.
+	 */
+	if (key->keysz > ntupatts)
+		return 1;
+
+	/*
+	 * Use the heap TID attribute and scantid to try to break the tie.  The
+	 * rules are the same as any other key attribute -- only the
+	 * representation differs.
+	 */
+	heapTid = BTreeTupleGetHeapTID(itup);
+	if (key->scantid == NULL)
+	{
+		/*
+		 * Forward scans have a scankey that is considered greater than a
+		 * truncated pivot tuple if and when the scankey has equal values for
+		 * attributes up to and including the least significant untruncated
+		 * attribute in tuple.  Even attributes that were omitted from the
+		 * scan key are considered greater than -inf truncated attributes.
+		 * (See _bt_binsrch for an explanation of our backward scan behavior.)
+		 *
+		 * For example, if an index has the minimum two attributes (single
+		 * user key attribute, plus heap TID attribute), and a page's high key
+		 * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
+		 * will not descend to the page to the left.  The search will descend
+		 * right instead.  The truncated attribute in pivot tuple means that
+		 * all non-pivot tuples on the page to the left are strictly < 'foo',
+		 * so it isn't necessary to descend left.  In other words, search
+		 * doesn't have to descend left because it isn't interested in a match
+		 * that has a heap TID value of -inf.
+		 *
+		 * Note: the heap TID part of the test ensures that scankey is being
+		 * compared to a pivot tuple with one or more truncated -inf key
+		 * attributes.  The heap TID attribute is the last key attribute in
+		 * every index, of course, but other than that it isn't special.
+		 */
+		if (!key->backward && key->keysz == ntupatts && heapTid == NULL &&
+			key->heapkeyspace)
+			return 1;
+
+		/* All provided scankey arguments found to be equal */
+		return 0;
+	}
+
+	/*
+	 * Treat truncated heap TID as minus infinity, since scankey has a key
+	 * attribute value (scantid) that would otherwise be compared directly
+	 */
+	Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
+	if (heapTid == NULL)
+		return 1;
+
+	/*
+	 * Scankey must be treated as equal to a posting list tuple if its scantid
+	 * value falls within the range of the posting list.  In all other cases
+	 * there can only be a single heap TID value, which is compared directly
+	 * with scantid.
+	 */
+	Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
+	result = ItemPointerCompare(key->scantid, heapTid);
+	if (result <= 0 || !BTreeTupleIsPosting(itup))
+		return result;
+	else
+	{
+		result = ItemPointerCompare(key->scantid,
+									BTreeTupleGetMaxHeapTID(itup));
+		if (result > 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ *	_bt_readpage() -- Load data from current index page into so->currPos
+ *
+ * Caller must have pinned and read-locked so->currPos.buf; the buffer's state
+ * is not changed here.  Also, currPos.moreLeft and moreRight must be valid;
+ * they are updated as appropriate.  All other fields of so->currPos are
+ * initialized from scratch here.
+ *
+ * We scan the current page starting at offnum and moving in the indicated
+ * direction.  All items matching the scan keys are loaded into currPos.items.
+ * moreLeft or moreRight (as appropriate) is cleared if _bt_checkkeys reports
+ * that there can be no more matching tuples in the current scan direction.
+ *
+ * _bt_first caller passes us an offnum returned by _bt_binsrch, which might
+ * be an out of bounds offnum such as "maxoff + 1" in certain corner cases.
+ * _bt_checkkeys will stop the scan as soon as an equality qual fails (when
+ * its scan key was marked required), so _bt_first _must_ pass us an offnum
+ * exactly at the beginning of where equal tuples are to be found.  When we're
+ * passed an offnum past the end of the page, we might still manage to stop
+ * the scan on this page by calling _bt_checkkeys against the high key.
+ *
+ * In the case of a parallel scan, caller must have called _bt_parallel_seize
+ * prior to calling this function; this function will invoke
+ * _bt_parallel_release before returning.
+ *
+ * Returns true if any matching items found on the page, false if none.
+ */
+static bool
+_bt_readpage(IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum,
+			 bool firstPage)
+{
+	BTScanOpaque so = (BTScanOpaque) scan->opaque;
+	Page		page;
+	BTPageOpaque opaque;
+	OffsetNumber minoff;
+	OffsetNumber maxoff;
+	int			itemIndex;
+	bool		continuescan;
+	int			indnatts;
+	bool		continuescanPrechecked;
+	bool		haveFirstMatch = false;
+
+	/*
+	 * We must have the buffer pinned and locked, but the usual macro can't be
+	 * used here; this function is what makes it good for currPos.
+	 */
+	Assert(BufferIsValid(so->currPos.buf));
+
+	page = BufferGetPage(so->currPos.buf);
+	opaque = BTPageGetOpaque(page);
+
+	/* allow next page be processed by parallel worker */
+	if (scan->parallel_scan)
+	{
+		if (ScanDirectionIsForward(dir))
+			_bt_parallel_release(scan, opaque->btpo_next);
+		else
+			_bt_parallel_release(scan, BufferGetBlockNumber(so->currPos.buf));
+	}
+
+	continuescan = true;		/* default assumption */
+	indnatts = IndexRelationGetNumberOfAttributes(scan->indexRelation);
+	minoff = P_FIRSTDATAKEY(opaque);
+	maxoff = PageGetMaxOffsetNumber(page);
+
+	/*
+	 * We note the buffer's block number so that we can release the pin later.
+	 * This allows us to re-read the buffer if it is needed again for hinting.
+	 */
+	so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
+
+	/*
+	 * We save the LSN of the page as we read it, so that we know whether it
+	 * safe to apply LP_DEAD hints to the page later.  This allows us to drop
+	 * the pin for MVCC scans, which allows vacuum to avoid blocking.
+	 */
+	so->currPos.lsn = BufferGetLSNAtomic(so->currPos.buf);
+
+	/*
+	 * we must save the page's right-link while scanning it; this tells us
+	 * where to step right to after we're done with these items.  There is no
+	 * corresponding need for the left-link, since splits always go right.
+	 */
+	so->currPos.nextPage = opaque->btpo_next;
+
+	/* initialize tuple workspace to empty */
+	so->currPos.nextTupleOffset = 0;
+
+	/*
+	 * Now that the current page has been made consistent, the macro should be
+	 * good.
+	 */
+	Assert(BTScanPosIsPinned(so->currPos));
+
+	/*
+	 * Prechecking the value of the continuescan flag for the last item on the
+	 * page (for backwards scan it will be the first item on a page).  If we
+	 * observe it to be true, then it should be true for all other items. This
+	 * allows us to do significant optimizations in the _bt_checkkeys()
+	 * function for all the items on the page.
+	 *
+	 * With the forward scan, we do this check for the last item on the page
+	 * instead of the high key.  It's relatively likely that the most
+	 * significant column in the high key will be different from the
+	 * corresponding value from the last item on the page.  So checking with
+	 * the last item on the page would give a more precise answer.
+	 *
+	 * We skip this for the first page in the scan to evade the possible
+	 * slowdown of the point queries.
+	 */
+	if (!firstPage && minoff < maxoff)
+	{
+		ItemId		iid;
+		IndexTuple	itup;
+
+		iid = PageGetItemId(page, ScanDirectionIsForward(dir) ? maxoff : minoff);
+		itup = (IndexTuple) PageGetItem(page, iid);
+
+		/*
+		 * Do the precheck.  Note that we pass the pointer to the
+		 * 'continuescanPrechecked' to the 'continuescan' argument. That will
+		 * set flag to true if all required keys are satisfied and false
+		 * otherwise.
+		 */
+		(void) _bt_checkkeys(scan, itup, indnatts, dir,
+							 &continuescanPrechecked, false, false);
+	}
+	else
+	{
+		continuescanPrechecked = false;
+	}
+
+	if (ScanDirectionIsForward(dir))
+	{
+		/* load items[] in ascending order */
+		itemIndex = 0;
+
+		offnum = Max(offnum, minoff);
+
+		while (offnum <= maxoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				offnum = OffsetNumberNext(offnum);
+				continue;
+			}
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+			Assert(!BTreeTupleIsPivot(itup));
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan,
+										 continuescanPrechecked,
+										 haveFirstMatch);
+
+			/*
+			 * If the result of prechecking required keys was true, then in
+			 * assert-enabled builds we also recheck that the _bt_checkkeys()
+			 * result is the same.
+			 */
+			Assert((!continuescanPrechecked && haveFirstMatch) ||
+				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
+												 &continuescan, false, false));
+			if (passes_quals)
+			{
+				/* tuple passes all scan key conditions */
+				haveFirstMatch = true;
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					_bt_saveitem(so, itemIndex, offnum, itup);
+					itemIndex++;
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID
+					 */
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					itemIndex++;
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+						itemIndex++;
+					}
+				}
+			}
+			/* When !continuescan, there can't be any more matches, so stop */
+			if (!continuescan)
+				break;
+
+			offnum = OffsetNumberNext(offnum);
+		}
+
+		/*
+		 * We don't need to visit page to the right when the high key
+		 * indicates that no more matches will be found there.
+		 *
+		 * Checking the high key like this works out more often than you might
+		 * think.  Leaf page splits pick a split point between the two most
+		 * dissimilar tuples (this is weighed against the need to evenly share
+		 * free space).  Leaf pages with high key attribute values that can
+		 * only appear on non-pivot tuples on the right sibling page are
+		 * common.
+		 */
+		if (continuescan && !P_RIGHTMOST(opaque))
+		{
+			ItemId		iid = PageGetItemId(page, P_HIKEY);
+			IndexTuple	itup = (IndexTuple) PageGetItem(page, iid);
+			int			truncatt;
+
+			truncatt = BTreeTupleGetNAtts(itup, scan->indexRelation);
+			_bt_checkkeys(scan, itup, truncatt, dir, &continuescan, false, false);
+		}
+
+		if (!continuescan)
+			so->currPos.moreRight = false;
+
+		Assert(itemIndex <= MaxTIDsPerBTreePage);
+		so->currPos.firstItem = 0;
+		so->currPos.lastItem = itemIndex - 1;
+		so->currPos.itemIndex = 0;
+	}
+	else
+	{
+		/* load items[] in descending order */
+		itemIndex = MaxTIDsPerBTreePage;
+
+		offnum = Min(offnum, maxoff);
+
+		while (offnum >= minoff)
+		{
+			ItemId		iid = PageGetItemId(page, offnum);
+			IndexTuple	itup;
+			bool		tuple_alive;
+			bool		passes_quals;
+
+			/*
+			 * If the scan specifies not to return killed tuples, then we
+			 * treat a killed tuple as not passing the qual.  Most of the
+			 * time, it's a win to not bother examining the tuple's index
+			 * keys, but just skip to the next tuple (previous, actually,
+			 * since we're scanning backwards).  However, if this is the first
+			 * tuple on the page, we do check the index keys, to prevent
+			 * uselessly advancing to the page to the left.  This is similar
+			 * to the high key optimization used by forward scans.
+			 */
+			if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
+			{
+				Assert(offnum >= P_FIRSTDATAKEY(opaque));
+				if (offnum > P_FIRSTDATAKEY(opaque))
+				{
+					offnum = OffsetNumberPrev(offnum);
+					continue;
+				}
+
+				tuple_alive = false;
+			}
+			else
+				tuple_alive = true;
+
+			itup = (IndexTuple) PageGetItem(page, iid);
+			Assert(!BTreeTupleIsPivot(itup));
+
+			passes_quals = _bt_checkkeys(scan, itup, indnatts, dir,
+										 &continuescan,
+										 continuescanPrechecked,
+										 haveFirstMatch);
+
+			/*
+			 * If the result of prechecking required keys was true, then in
+			 * assert-enabled builds we also recheck that the _bt_checkkeys()
+			 * result is the same.
+			 */
+			Assert((!continuescanPrechecked && !haveFirstMatch) ||
+				   passes_quals == _bt_checkkeys(scan, itup, indnatts, dir,
+												 &continuescan, false, false));
+			if (passes_quals && tuple_alive)
+			{
+				/* tuple passes all scan key conditions */
+				haveFirstMatch = true;
+				if (!BTreeTupleIsPosting(itup))
+				{
+					/* Remember it */
+					itemIndex--;
+					_bt_saveitem(so, itemIndex, offnum, itup);
+				}
+				else
+				{
+					int			tupleOffset;
+
+					/*
+					 * Set up state to return posting list, and remember first
+					 * TID.
+					 *
+					 * Note that we deliberately save/return items from
+					 * posting lists in ascending heap TID order for backwards
+					 * scans.  This allows _bt_killitems() to make a
+					 * consistent assumption about the order of items
+					 * associated with the same posting list tuple.
+					 */
+					itemIndex--;
+					tupleOffset =
+						_bt_setuppostingitems(so, itemIndex, offnum,
+											  BTreeTupleGetPostingN(itup, 0),
+											  itup);
+					/* Remember additional TIDs */
+					for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
+					{
+						itemIndex--;
+						_bt_savepostingitem(so, itemIndex, offnum,
+											BTreeTupleGetPostingN(itup, i),
+											tupleOffset);
+					}
+				}
+			}
+			if (!continuescan)
+			{
+				/* there can't be any more matches, so stop */
+				so->currPos.moreLeft = false;
+				break;
+			}
+
+			offnum = OffsetNumberPrev(offnum);
+		}
+
+		Assert(itemIndex >= 0);
+		so->currPos.firstItem = itemIndex;
+		so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
+		so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
+	}
+
+	return (so->currPos.firstItem <= so->currPos.lastItem);
+}
diff --git a/src/backend/access/nbtree/nbtsort.c b/src/backend/access/nbtree/nbtsort.c
index f5d7b3b0c3..f2c96af23b 100644
--- a/src/backend/access/nbtree/nbtsort.c
+++ b/src/backend/access/nbtree/nbtsort.c
@@ -271,8 +271,6 @@ static void _bt_sort_dedup_finish_pending(BTWriteState *wstate,
 										  BTPageState *state,
 										  BTDedupState dstate);
 static void _bt_uppershutdown(BTWriteState *wstate, BTPageState *state);
-static void _bt_load(BTWriteState *wstate,
-					 BTSpool *btspool, BTSpool *btspool2);
 static void _bt_begin_parallel(BTBuildState *buildstate, bool isconcurrent,
 							   int request);
 static void _bt_end_parallel(BTLeader *btleader);
@@ -285,6 +283,7 @@ static void _bt_parallel_scan_and_sort(BTSpool *btspool, BTSpool *btspool2,
 									   Sharedsort *sharedsort2, int sortmem,
 									   bool progress);
 
+#include "nbtsort_spec.c"
 
 /*
  *	btbuild() -- build a new btree index.
@@ -1127,255 +1126,6 @@ _bt_uppershutdown(BTWriteState *wstate, BTPageState *state)
 	_bt_blwritepage(wstate, metabuf, BTREE_METAPAGE);
 }
 
-/*
- * Read tuples in correct sort order from tuplesort, and load them into
- * btree leaves.
- */
-static void
-_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
-{
-	BTPageState *state = NULL;
-	bool		merge = (btspool2 != NULL);
-	IndexTuple	itup,
-				itup2 = NULL;
-	bool		load1;
-	TupleDesc	tupdes = RelationGetDescr(wstate->index);
-	int			i,
-				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
-	SortSupport sortKeys;
-	int64		tuples_done = 0;
-	bool		deduplicate;
-
-	wstate->bulkstate = smgr_bulk_start_rel(wstate->index, MAIN_FORKNUM);
-
-	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
-		BTGetDeduplicateItems(wstate->index);
-
-	if (merge)
-	{
-		/*
-		 * Another BTSpool for dead tuples exists. Now we have to merge
-		 * btspool and btspool2.
-		 */
-
-		/* the preparation of merge */
-		itup = tuplesort_getindextuple(btspool->sortstate, true);
-		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-
-		/* Prepare SortSupport data for each column */
-		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
-
-		for (i = 0; i < keysz; i++)
-		{
-			SortSupport sortKey = sortKeys + i;
-			ScanKey		scanKey = wstate->inskey->scankeys + i;
-			int16		strategy;
-
-			sortKey->ssup_cxt = CurrentMemoryContext;
-			sortKey->ssup_collation = scanKey->sk_collation;
-			sortKey->ssup_nulls_first =
-				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
-			sortKey->ssup_attno = scanKey->sk_attno;
-			/* Abbreviation is not supported here */
-			sortKey->abbreviate = false;
-
-			Assert(sortKey->ssup_attno != 0);
-
-			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
-				BTGreaterStrategyNumber : BTLessStrategyNumber;
-
-			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
-		}
-
-		for (;;)
-		{
-			load1 = true;		/* load BTSpool next ? */
-			if (itup2 == NULL)
-			{
-				if (itup == NULL)
-					break;
-			}
-			else if (itup != NULL)
-			{
-				int32		compare = 0;
-
-				for (i = 1; i <= keysz; i++)
-				{
-					SortSupport entry;
-					Datum		attrDatum1,
-								attrDatum2;
-					bool		isNull1,
-								isNull2;
-
-					entry = sortKeys + i - 1;
-					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
-					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
-
-					compare = ApplySortComparator(attrDatum1, isNull1,
-												  attrDatum2, isNull2,
-												  entry);
-					if (compare > 0)
-					{
-						load1 = false;
-						break;
-					}
-					else if (compare < 0)
-						break;
-				}
-
-				/*
-				 * If key values are equal, we sort on ItemPointer.  This is
-				 * required for btree indexes, since heap TID is treated as an
-				 * implicit last key attribute in order to ensure that all
-				 * keys in the index are physically unique.
-				 */
-				if (compare == 0)
-				{
-					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
-					Assert(compare != 0);
-					if (compare > 0)
-						load1 = false;
-				}
-			}
-			else
-				load1 = false;
-
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			if (load1)
-			{
-				_bt_buildadd(wstate, state, itup, 0);
-				itup = tuplesort_getindextuple(btspool->sortstate, true);
-			}
-			else
-			{
-				_bt_buildadd(wstate, state, itup2, 0);
-				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-		pfree(sortKeys);
-	}
-	else if (deduplicate)
-	{
-		/* merge is unnecessary, deduplicate into posting lists */
-		BTDedupState dstate;
-
-		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
-		dstate->deduplicate = true; /* unused */
-		dstate->nmaxitems = 0;	/* unused */
-		dstate->maxpostingsize = 0; /* set later */
-		/* Metadata about base tuple of current pending posting list */
-		dstate->base = NULL;
-		dstate->baseoff = InvalidOffsetNumber;	/* unused */
-		dstate->basetupsize = 0;
-		/* Metadata about current pending posting list TIDs */
-		dstate->htids = NULL;
-		dstate->nhtids = 0;
-		dstate->nitems = 0;
-		dstate->phystupsize = 0;	/* unused */
-		dstate->nintervals = 0; /* unused */
-
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-			{
-				state = _bt_pagestate(wstate, 0);
-
-				/*
-				 * Limit size of posting list tuples to 1/10 space we want to
-				 * leave behind on the page, plus space for final item's line
-				 * pointer.  This is equal to the space that we'd like to
-				 * leave behind on each leaf page when fillfactor is 90,
-				 * allowing us to get close to fillfactor% space utilization
-				 * when there happen to be a great many duplicates.  (This
-				 * makes higher leaf fillfactor settings ineffective when
-				 * building indexes that have many duplicates, but packing
-				 * leaf pages full with few very large tuples doesn't seem
-				 * like a useful goal.)
-				 */
-				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
-					sizeof(ItemIdData);
-				Assert(dstate->maxpostingsize <= BTMaxItemSize((Page) state->btps_buf) &&
-					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
-				dstate->htids = palloc(dstate->maxpostingsize);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
-										 itup) > keysz &&
-					 _bt_dedup_save_htid(dstate, itup))
-			{
-				/*
-				 * Tuple is equal to base tuple of pending posting list.  Heap
-				 * TID from itup has been saved in state.
-				 */
-			}
-			else
-			{
-				/*
-				 * Tuple is not equal to pending posting list tuple, or
-				 * _bt_dedup_save_htid() opted to not merge current item into
-				 * pending posting list.
-				 */
-				_bt_sort_dedup_finish_pending(wstate, state, dstate);
-				pfree(dstate->base);
-
-				/* start new pending posting list with itup copy */
-				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
-										InvalidOffsetNumber);
-			}
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-
-		if (state)
-		{
-			/*
-			 * Handle the last item (there must be a last item when the
-			 * tuplesort returned one or more tuples)
-			 */
-			_bt_sort_dedup_finish_pending(wstate, state, dstate);
-			pfree(dstate->base);
-			pfree(dstate->htids);
-		}
-
-		pfree(dstate);
-	}
-	else
-	{
-		/* merging and deduplication are both unnecessary */
-		while ((itup = tuplesort_getindextuple(btspool->sortstate,
-											   true)) != NULL)
-		{
-			/* When we see first tuple, create first index page */
-			if (state == NULL)
-				state = _bt_pagestate(wstate, 0);
-
-			_bt_buildadd(wstate, state, itup, 0);
-
-			/* Report progress */
-			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
-										 ++tuples_done);
-		}
-	}
-
-	/* Close down final pages and write the metapage */
-	_bt_uppershutdown(wstate, state);
-	smgr_bulk_finish(wstate->bulkstate);
-}
-
 /*
  * Create parallel context, and launch workers for leader.
  *
diff --git a/src/backend/access/nbtree/nbtsort_spec.c b/src/backend/access/nbtree/nbtsort_spec.c
new file mode 100644
index 0000000000..c9d03d771f
--- /dev/null
+++ b/src/backend/access/nbtree/nbtsort_spec.c
@@ -0,0 +1,269 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtsort_spec.c
+ *	  Index shape-specialized functions for nbtsort.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtsort_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static void _bt_load(BTWriteState *wstate,
+					 BTSpool *btspool, BTSpool *btspool2);
+
+/*
+ * Read tuples in correct sort order from tuplesort, and load them into
+ * btree leaves.
+ */
+static void
+_bt_load(BTWriteState *wstate, BTSpool *btspool, BTSpool *btspool2)
+{
+	BTPageState *state = NULL;
+	bool		merge = (btspool2 != NULL);
+	IndexTuple	itup,
+				itup2 = NULL;
+	bool		load1;
+	TupleDesc	tupdes = RelationGetDescr(wstate->index);
+	int			i,
+				keysz = IndexRelationGetNumberOfKeyAttributes(wstate->index);
+	SortSupport sortKeys;
+	int64		tuples_done = 0;
+	bool		deduplicate;
+
+	wstate->bulkstate = smgr_bulk_start_rel(wstate->index, MAIN_FORKNUM);
+
+	deduplicate = wstate->inskey->allequalimage && !btspool->isunique &&
+		BTGetDeduplicateItems(wstate->index);
+
+	if (merge)
+	{
+		/*
+		 * Another BTSpool for dead tuples exists. Now we have to merge
+		 * btspool and btspool2.
+		 */
+
+		/* the preparation of merge */
+		itup = tuplesort_getindextuple(btspool->sortstate, true);
+		itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+
+		/* Prepare SortSupport data for each column */
+		sortKeys = (SortSupport) palloc0(keysz * sizeof(SortSupportData));
+
+		for (i = 0; i < keysz; i++)
+		{
+			SortSupport sortKey = sortKeys + i;
+			ScanKey		scanKey = wstate->inskey->scankeys + i;
+			int16		strategy;
+
+			sortKey->ssup_cxt = CurrentMemoryContext;
+			sortKey->ssup_collation = scanKey->sk_collation;
+			sortKey->ssup_nulls_first =
+				(scanKey->sk_flags & SK_BT_NULLS_FIRST) != 0;
+			sortKey->ssup_attno = scanKey->sk_attno;
+			/* Abbreviation is not supported here */
+			sortKey->abbreviate = false;
+
+			Assert(sortKey->ssup_attno != 0);
+
+			strategy = (scanKey->sk_flags & SK_BT_DESC) != 0 ?
+				BTGreaterStrategyNumber : BTLessStrategyNumber;
+
+			PrepareSortSupportFromIndexRel(wstate->index, strategy, sortKey);
+		}
+
+		for (;;)
+		{
+			load1 = true;		/* load BTSpool next ? */
+			if (itup2 == NULL)
+			{
+				if (itup == NULL)
+					break;
+			}
+			else if (itup != NULL)
+			{
+				int32		compare = 0;
+
+				for (i = 1; i <= keysz; i++)
+				{
+					SortSupport entry;
+					Datum		attrDatum1,
+								attrDatum2;
+					bool		isNull1,
+								isNull2;
+
+					entry = sortKeys + i - 1;
+					attrDatum1 = index_getattr(itup, i, tupdes, &isNull1);
+					attrDatum2 = index_getattr(itup2, i, tupdes, &isNull2);
+
+					compare = ApplySortComparator(attrDatum1, isNull1,
+												  attrDatum2, isNull2,
+												  entry);
+					if (compare > 0)
+					{
+						load1 = false;
+						break;
+					}
+					else if (compare < 0)
+						break;
+				}
+
+				/*
+				 * If key values are equal, we sort on ItemPointer.  This is
+				 * required for btree indexes, since heap TID is treated as an
+				 * implicit last key attribute in order to ensure that all
+				 * keys in the index are physically unique.
+				 */
+				if (compare == 0)
+				{
+					compare = ItemPointerCompare(&itup->t_tid, &itup2->t_tid);
+					Assert(compare != 0);
+					if (compare > 0)
+						load1 = false;
+				}
+			}
+			else
+				load1 = false;
+
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			if (load1)
+			{
+				_bt_buildadd(wstate, state, itup, 0);
+				itup = tuplesort_getindextuple(btspool->sortstate, true);
+			}
+			else
+			{
+				_bt_buildadd(wstate, state, itup2, 0);
+				itup2 = tuplesort_getindextuple(btspool2->sortstate, true);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+		pfree(sortKeys);
+	}
+	else if (deduplicate)
+	{
+		/* merge is unnecessary, deduplicate into posting lists */
+		BTDedupState dstate;
+
+		dstate = (BTDedupState) palloc(sizeof(BTDedupStateData));
+		dstate->deduplicate = true; /* unused */
+		dstate->nmaxitems = 0;	/* unused */
+		dstate->maxpostingsize = 0; /* set later */
+		/* Metadata about base tuple of current pending posting list */
+		dstate->base = NULL;
+		dstate->baseoff = InvalidOffsetNumber;	/* unused */
+		dstate->basetupsize = 0;
+		/* Metadata about current pending posting list TIDs */
+		dstate->htids = NULL;
+		dstate->nhtids = 0;
+		dstate->nitems = 0;
+		dstate->phystupsize = 0;	/* unused */
+		dstate->nintervals = 0; /* unused */
+
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+			{
+				state = _bt_pagestate(wstate, 0);
+
+				/*
+				 * Limit size of posting list tuples to 1/10 space we want to
+				 * leave behind on the page, plus space for final item's line
+				 * pointer.  This is equal to the space that we'd like to
+				 * leave behind on each leaf page when fillfactor is 90,
+				 * allowing us to get close to fillfactor% space utilization
+				 * when there happen to be a great many duplicates.  (This
+				 * makes higher leaf fillfactor settings ineffective when
+				 * building indexes that have many duplicates, but packing
+				 * leaf pages full with few very large tuples doesn't seem
+				 * like a useful goal.)
+				 */
+				dstate->maxpostingsize = MAXALIGN_DOWN((BLCKSZ * 10 / 100)) -
+					sizeof(ItemIdData);
+				Assert(dstate->maxpostingsize <= BTMaxItemSize((Page) state->btps_buf) &&
+					   dstate->maxpostingsize <= INDEX_SIZE_MASK);
+				dstate->htids = palloc(dstate->maxpostingsize);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+			else if (_bt_keep_natts_fast(wstate->index, dstate->base,
+										 itup) > keysz &&
+					 _bt_dedup_save_htid(dstate, itup))
+			{
+				/*
+				 * Tuple is equal to base tuple of pending posting list.  Heap
+				 * TID from itup has been saved in state.
+				 */
+			}
+			else
+			{
+				/*
+				 * Tuple is not equal to pending posting list tuple, or
+				 * _bt_dedup_save_htid() opted to not merge current item into
+				 * pending posting list.
+				 */
+				_bt_sort_dedup_finish_pending(wstate, state, dstate);
+				pfree(dstate->base);
+
+				/* start new pending posting list with itup copy */
+				_bt_dedup_start_pending(dstate, CopyIndexTuple(itup),
+										InvalidOffsetNumber);
+			}
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+
+		if (state)
+		{
+			/*
+			 * Handle the last item (there must be a last item when the
+			 * tuplesort returned one or more tuples)
+			 */
+			_bt_sort_dedup_finish_pending(wstate, state, dstate);
+			pfree(dstate->base);
+			pfree(dstate->htids);
+		}
+
+		pfree(dstate);
+	}
+	else
+	{
+		/* merging and deduplication are both unnecessary */
+		while ((itup = tuplesort_getindextuple(btspool->sortstate,
+											   true)) != NULL)
+		{
+			/* When we see first tuple, create first index page */
+			if (state == NULL)
+				state = _bt_pagestate(wstate, 0);
+
+			_bt_buildadd(wstate, state, itup, 0);
+
+			/* Report progress */
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
+										 ++tuples_done);
+		}
+	}
+
+	/* Close down final pages and write the metapage */
+	_bt_uppershutdown(wstate, state);
+	smgr_bulk_finish(wstate->bulkstate);
+}
diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
index d50317096d..8cb0ee2351 100644
--- a/src/backend/access/nbtree/nbtutils.c
+++ b/src/backend/access/nbtree/nbtutils.c
@@ -49,122 +49,8 @@ static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op,
 									 bool *result);
 static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption);
 static void _bt_mark_scankey_required(ScanKey skey);
-static bool _bt_check_rowcompare(ScanKey skey,
-								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
-								 ScanDirection dir, bool *continuescan);
-static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
-						   IndexTuple firstright, BTScanInsert itup_key);
 
-
-/*
- * _bt_mkscankey
- *		Build an insertion scan key that contains comparison data from itup
- *		as well as comparator routines appropriate to the key datatypes.
- *
- *		The result is intended for use with _bt_compare() and _bt_truncate().
- *		Callers that don't need to fill out the insertion scankey arguments
- *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
- *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
- *		be initialized as if an "all truncated" pivot tuple was passed
- *		instead.
- *
- *		Note that we may occasionally have to share lock the metapage to
- *		determine whether or not the keys in the index are expected to be
- *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
- *		heapkeyspace index when caller passes a NULL tuple, allowing index
- *		build callers to avoid accessing the non-existent metapage.  We
- *		also assume that the index is _not_ allequalimage when a NULL tuple
- *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
- *		field themselves.
- */
-BTScanInsert
-_bt_mkscankey(Relation rel, IndexTuple itup)
-{
-	BTScanInsert key;
-	ScanKey		skey;
-	TupleDesc	itupdesc;
-	int			indnkeyatts;
-	int16	   *indoption;
-	int			tupnatts;
-	int			i;
-
-	itupdesc = RelationGetDescr(rel);
-	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	indoption = rel->rd_indoption;
-	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
-
-	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
-
-	/*
-	 * We'll execute search using scan key constructed on key columns.
-	 * Truncated attributes and non-key attributes are omitted from the final
-	 * scan key.
-	 */
-	key = palloc(offsetof(BTScanInsertData, scankeys) +
-				 sizeof(ScanKeyData) * indnkeyatts);
-	if (itup)
-		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
-	else
-	{
-		/* Utility statement callers can set these fields themselves */
-		key->heapkeyspace = true;
-		key->allequalimage = false;
-	}
-	key->anynullkeys = false;	/* initial assumption */
-	key->nextkey = false;		/* usual case, required by btinsert */
-	key->backward = false;		/* usual case, required by btinsert */
-	key->keysz = Min(indnkeyatts, tupnatts);
-	key->scantid = key->heapkeyspace && itup ?
-		BTreeTupleGetHeapTID(itup) : NULL;
-	skey = key->scankeys;
-	for (i = 0; i < indnkeyatts; i++)
-	{
-		FmgrInfo   *procinfo;
-		Datum		arg;
-		bool		null;
-		int			flags;
-
-		/*
-		 * We can use the cached (default) support procs since no cross-type
-		 * comparison can be needed.
-		 */
-		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
-
-		/*
-		 * Key arguments built from truncated attributes (or when caller
-		 * provides no tuple) are defensively represented as NULL values. They
-		 * should never be used.
-		 */
-		if (i < tupnatts)
-			arg = index_getattr(itup, i + 1, itupdesc, &null);
-		else
-		{
-			arg = (Datum) 0;
-			null = true;
-		}
-		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
-		ScanKeyEntryInitializeWithInfo(&skey[i],
-									   flags,
-									   (AttrNumber) (i + 1),
-									   InvalidStrategy,
-									   InvalidOid,
-									   rel->rd_indcollation[i],
-									   procinfo,
-									   arg);
-		/* Record if any key attribute is NULL (or truncated) */
-		if (null)
-			key->anynullkeys = true;
-	}
-
-	/*
-	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
-	 * that full uniqueness check is done.
-	 */
-	if (rel->rd_index->indnullsnotdistinct)
-		key->anynullkeys = false;
-
-	return key;
-}
+#include "nbtutils_spec.c"
 
 /*
  * free a retracement stack made by _bt_search.
@@ -1346,401 +1232,6 @@ _bt_mark_scankey_required(ScanKey skey)
 	}
 }
 
-/*
- * Test whether an indextuple satisfies all the scankey conditions.
- *
- * Return true if so, false if not.  If the tuple fails to pass the qual,
- * we also determine whether there's any need to continue the scan beyond
- * this tuple, and set *continuescan accordingly.  See comments for
- * _bt_preprocess_keys(), above, about how this is done.
- *
- * Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescan to false, and avoiding an unnecessary visit to
- * the page to the right.
- *
- * scan: index scan descriptor (containing a search-type scankey)
- * tuple: index tuple to test
- * tupnatts: number of attributes in tupnatts (high key may be truncated)
- * dir: direction we are scanning in
- * continuescan: output parameter (will be set correctly in all cases)
- * continuescanPrechecked: indicates that *continuescan flag is known to
- * 						   be true for the last item on the page
- * haveFirstMatch: indicates that we already have at least one match
- * 							  in the current page
- */
-bool
-_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
-			  ScanDirection dir, bool *continuescan,
-			  bool continuescanPrechecked, bool haveFirstMatch)
-{
-	TupleDesc	tupdesc;
-	BTScanOpaque so;
-	int			keysz;
-	int			ikey;
-	ScanKey		key;
-
-	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
-
-	*continuescan = true;		/* default assumption */
-
-	tupdesc = RelationGetDescr(scan->indexRelation);
-	so = (BTScanOpaque) scan->opaque;
-	keysz = so->numberOfKeys;
-
-	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
-	{
-		Datum		datum;
-		bool		isNull;
-		Datum		test;
-		bool		requiredSameDir = false,
-					requiredOppositeDir = false;
-
-		/*
-		 * Check if the key is required for ordered scan in the same or
-		 * opposite direction.  Save as flag variables for future usage.
-		 */
-		if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsForward(dir)) ||
-			((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsBackward(dir)))
-			requiredSameDir = true;
-		else if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsBackward(dir)) ||
-				 ((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsForward(dir)))
-			requiredOppositeDir = true;
-
-		/*
-		 * If the caller told us the *continuescan flag is known to be true
-		 * for the last item on the page, then we know the keys required for
-		 * the current direction scan should be matched.  Otherwise, the
-		 * *continuescan flag would be set for the current item and
-		 * subsequently the last item on the page accordingly.
-		 *
-		 * If the key is required for the opposite direction scan, we can skip
-		 * the check if the caller tells us there was already at least one
-		 * matching item on the page. Also, we require the *continuescan flag
-		 * to be true for the last item on the page to know there are no
-		 * NULLs.
-		 *
-		 * Both cases above work except for the row keys, where NULLs could be
-		 * found in the middle of matching values.
-		 */
-		if ((requiredSameDir || (requiredOppositeDir && haveFirstMatch)) &&
-			!(key->sk_flags & SK_ROW_HEADER) && continuescanPrechecked)
-			continue;
-
-		if (key->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			continue;
-		}
-
-		/* row-comparison keys need special processing */
-		if (key->sk_flags & SK_ROW_HEADER)
-		{
-			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
-									 continuescan))
-				continue;
-			return false;
-		}
-
-		datum = index_getattr(tuple,
-							  key->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (key->sk_flags & SK_ISNULL)
-		{
-			/* Handle IS NULL/NOT NULL tests */
-			if (key->sk_flags & SK_SEARCHNULL)
-			{
-				if (isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-			else
-			{
-				Assert(key->sk_flags & SK_SEARCHNOTNULL);
-				if (!isNull)
-					continue;	/* tuple satisfies this qual */
-			}
-
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 */
-			if (requiredSameDir)
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (isNull)
-		{
-			if (key->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		/*
-		 * Apply the key-checking function.  When the key is required for the
-		 * opposite direction scan, it must be already satisfied as soon as
-		 * there is already match on the page.  Except for the NULLs checking,
-		 * which have already done above.
-		 */
-		if (!(requiredOppositeDir && haveFirstMatch))
-		{
-			test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
-									 datum, key->sk_argument);
-		}
-		else
-		{
-			test = true;
-			Assert(test == FunctionCall2Coll(&key->sk_func, key->sk_collation,
-											 datum, key->sk_argument));
-		}
-
-		if (!DatumGetBool(test))
-		{
-			/*
-			 * Tuple fails this qual.  If it's a required qual for the current
-			 * scan direction, then we can conclude no further tuples will
-			 * pass, either.
-			 *
-			 * Note: because we stop the scan as soon as any required equality
-			 * qual fails, it is critical that equality quals be used for the
-			 * initial positioning in _bt_first() when they are available. See
-			 * comments in _bt_first().
-			 */
-			if (requiredSameDir)
-				*continuescan = false;
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-	}
-
-	/* If we get here, the tuple passes all index quals. */
-	return true;
-}
-
-/*
- * Test whether an indextuple satisfies a row-comparison scan condition.
- *
- * Return true if so, false if not.  If not, also clear *continuescan if
- * it's not possible for any future tuples in the current scan direction
- * to pass the qual.
- *
- * This is a subroutine for _bt_checkkeys, which see for more info.
- */
-static bool
-_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
-					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
-{
-	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
-	int32		cmpresult = 0;
-	bool		result;
-
-	/* First subkey should be same as the header says */
-	Assert(subkey->sk_attno == skey->sk_attno);
-
-	/* Loop over columns of the row condition */
-	for (;;)
-	{
-		Datum		datum;
-		bool		isNull;
-
-		Assert(subkey->sk_flags & SK_ROW_MEMBER);
-
-		if (subkey->sk_attno > tupnatts)
-		{
-			/*
-			 * This attribute is truncated (must be high key).  The value for
-			 * this attribute in the first non-pivot tuple on the page to the
-			 * right could be any possible value.  Assume that truncated
-			 * attribute passes the qual.
-			 */
-			Assert(ScanDirectionIsForward(dir));
-			Assert(BTreeTupleIsPivot(tuple));
-			cmpresult = 0;
-			if (subkey->sk_flags & SK_ROW_END)
-				break;
-			subkey++;
-			continue;
-		}
-
-		datum = index_getattr(tuple,
-							  subkey->sk_attno,
-							  tupdesc,
-							  &isNull);
-
-		if (isNull)
-		{
-			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
-			{
-				/*
-				 * Since NULLs are sorted before non-NULLs, we know we have
-				 * reached the lower limit of the range of values for this
-				 * index attr.  On a backward scan, we can stop if this qual
-				 * is one of the "must match" subset.  We can stop regardless
-				 * of whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a forward scan, however, we must keep going, because we may
-				 * have initially positioned to the start of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsBackward(dir))
-					*continuescan = false;
-			}
-			else
-			{
-				/*
-				 * Since NULLs are sorted after non-NULLs, we know we have
-				 * reached the upper limit of the range of values for this
-				 * index attr.  On a forward scan, we can stop if this qual is
-				 * one of the "must match" subset.  We can stop regardless of
-				 * whether the qual is > or <, so long as it's required,
-				 * because it's not possible for any future tuples to pass. On
-				 * a backward scan, however, we must keep going, because we
-				 * may have initially positioned to the end of the index.
-				 */
-				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
-					ScanDirectionIsForward(dir))
-					*continuescan = false;
-			}
-
-			/*
-			 * In any case, this indextuple doesn't match the qual.
-			 */
-			return false;
-		}
-
-		if (subkey->sk_flags & SK_ISNULL)
-		{
-			/*
-			 * Unlike the simple-scankey case, this isn't a disallowed case.
-			 * But it can never match.  If all the earlier row comparison
-			 * columns are required for the scan direction, we can stop the
-			 * scan, because there can't be another tuple that will succeed.
-			 */
-			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
-				subkey--;
-			if ((subkey->sk_flags & SK_BT_REQFWD) &&
-				ScanDirectionIsForward(dir))
-				*continuescan = false;
-			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-					 ScanDirectionIsBackward(dir))
-				*continuescan = false;
-			return false;
-		}
-
-		/* Perform the test --- three-way comparison not bool operator */
-		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
-													subkey->sk_collation,
-													datum,
-													subkey->sk_argument));
-
-		if (subkey->sk_flags & SK_BT_DESC)
-			INVERT_COMPARE_RESULT(cmpresult);
-
-		/* Done comparing if unequal, else advance to next column */
-		if (cmpresult != 0)
-			break;
-
-		if (subkey->sk_flags & SK_ROW_END)
-			break;
-		subkey++;
-	}
-
-	/*
-	 * At this point cmpresult indicates the overall result of the row
-	 * comparison, and subkey points to the deciding column (or the last
-	 * column if the result is "=").
-	 */
-	switch (subkey->sk_strategy)
-	{
-			/* EQ and NE cases aren't allowed here */
-		case BTLessStrategyNumber:
-			result = (cmpresult < 0);
-			break;
-		case BTLessEqualStrategyNumber:
-			result = (cmpresult <= 0);
-			break;
-		case BTGreaterEqualStrategyNumber:
-			result = (cmpresult >= 0);
-			break;
-		case BTGreaterStrategyNumber:
-			result = (cmpresult > 0);
-			break;
-		default:
-			elog(ERROR, "unrecognized RowCompareType: %d",
-				 (int) subkey->sk_strategy);
-			result = 0;			/* keep compiler quiet */
-			break;
-	}
-
-	if (!result)
-	{
-		/*
-		 * Tuple fails this qual.  If it's a required qual for the current
-		 * scan direction, then we can conclude no further tuples will pass,
-		 * either.  Note we have to look at the deciding column, not
-		 * necessarily the first or last column of the row condition.
-		 */
-		if ((subkey->sk_flags & SK_BT_REQFWD) &&
-			ScanDirectionIsForward(dir))
-			*continuescan = false;
-		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
-				 ScanDirectionIsBackward(dir))
-			*continuescan = false;
-	}
-
-	return result;
-}
-
 /*
  * _bt_killitems - set LP_DEAD state for items an indexscan caller has
  * told us were killed
@@ -2224,286 +1715,6 @@ btbuildphasename(int64 phasenum)
 	}
 }
 
-/*
- *	_bt_truncate() -- create tuple without unneeded suffix attributes.
- *
- * Returns truncated pivot index tuple allocated in caller's memory context,
- * with key attributes copied from caller's firstright argument.  If rel is
- * an INCLUDE index, non-key attributes will definitely be truncated away,
- * since they're not part of the key space.  More aggressive suffix
- * truncation can take place when it's clear that the returned tuple does not
- * need one or more suffix key attributes.  We only need to keep firstright
- * attributes up to and including the first non-lastleft-equal attribute.
- * Caller's insertion scankey is used to compare the tuples; the scankey's
- * argument values are not considered here.
- *
- * Note that returned tuple's t_tid offset will hold the number of attributes
- * present, so the original item pointer offset is not represented.  Caller
- * should only change truncated tuple's downlink.  Note also that truncated
- * key attributes are treated as containing "minus infinity" values by
- * _bt_compare().
- *
- * In the worst case (when a heap TID must be appended to distinguish lastleft
- * from firstright), the size of the returned tuple is the size of firstright
- * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
- * is important, since callers need to stay under the 1/3 of a page
- * restriction on tuple size.  If this routine is ever taught to truncate
- * within an attribute/datum, it will need to avoid returning an enlarged
- * tuple to caller when truncation + TOAST compression ends up enlarging the
- * final datum.
- */
-IndexTuple
-_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			 BTScanInsert itup_key)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-	IndexTuple	pivot;
-	IndexTuple	tidpivot;
-	ItemPointer pivotheaptid;
-	Size		newsize;
-
-	/*
-	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
-	 * never okay to truncate when splitting an internal page.
-	 */
-	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
-
-	/* Determine how many attributes must be kept in truncated tuple */
-	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
-
-#ifdef DEBUG_NO_TRUNCATE
-	/* Force truncation to be ineffective for testing purposes */
-	keepnatts = nkeyatts + 1;
-#endif
-
-	pivot = index_truncate_tuple(itupdesc, firstright,
-								 Min(keepnatts, nkeyatts));
-
-	if (BTreeTupleIsPosting(pivot))
-	{
-		/*
-		 * index_truncate_tuple() just returns a straight copy of firstright
-		 * when it has no attributes to truncate.  When that happens, we may
-		 * need to truncate away a posting list here instead.
-		 */
-		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
-		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
-		pivot->t_info &= ~INDEX_SIZE_MASK;
-		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
-	}
-
-	/*
-	 * If there is a distinguishing key attribute within pivot tuple, we're
-	 * done
-	 */
-	if (keepnatts <= nkeyatts)
-	{
-		BTreeTupleSetNAtts(pivot, keepnatts, false);
-		return pivot;
-	}
-
-	/*
-	 * We have to store a heap TID in the new pivot tuple, since no non-TID
-	 * key attribute value in firstright distinguishes the right side of the
-	 * split from the left side.  nbtree conceptualizes this case as an
-	 * inability to truncate away any key attributes, since heap TID is
-	 * treated as just another key attribute (despite lacking a pg_attribute
-	 * entry).
-	 *
-	 * Use enlarged space that holds a copy of pivot.  We need the extra space
-	 * to store a heap TID at the end (using the special pivot tuple
-	 * representation).  Note that the original pivot already has firstright's
-	 * possible posting list/non-key attribute values removed at this point.
-	 */
-	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
-	tidpivot = palloc0(newsize);
-	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
-	/* Cannot leak memory here */
-	pfree(pivot);
-
-	/*
-	 * Store all of firstright's key attribute values plus a tiebreaker heap
-	 * TID value in enlarged pivot tuple
-	 */
-	tidpivot->t_info &= ~INDEX_SIZE_MASK;
-	tidpivot->t_info |= newsize;
-	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
-	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
-
-	/*
-	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
-	 * consider suffix truncation.  It seems like a good idea to follow that
-	 * example in cases where no truncation takes place -- use lastleft's heap
-	 * TID.  (This is also the closest value to negative infinity that's
-	 * legally usable.)
-	 */
-	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
-
-	/*
-	 * We're done.  Assert() that heap TID invariants hold before returning.
-	 *
-	 * Lehman and Yao require that the downlink to the right page, which is to
-	 * be inserted into the parent page in the second phase of a page split be
-	 * a strict lower bound on items on the right page, and a non-strict upper
-	 * bound for items on the left page.  Assert that heap TIDs follow these
-	 * invariants, since a heap TID value is apparently needed as a
-	 * tiebreaker.
-	 */
-#ifndef DEBUG_NO_TRUNCATE
-	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(lastleft)) >= 0);
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#else
-
-	/*
-	 * Those invariants aren't guaranteed to hold for lastleft + firstright
-	 * heap TID attribute values when they're considered here only because
-	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
-	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
-	 * TID value that always works as a strict lower bound for items to the
-	 * right.  In particular, it must avoid using firstright's leading key
-	 * attribute values along with lastleft's heap TID value when lastleft's
-	 * TID happens to be greater than firstright's TID.
-	 */
-	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
-
-	/*
-	 * Pivot heap TID should never be fully equal to firstright.  Note that
-	 * the pivot heap TID will still end up equal to lastleft's heap TID when
-	 * that's the only usable value.
-	 */
-	ItemPointerSetOffsetNumber(pivotheaptid,
-							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
-	Assert(ItemPointerCompare(pivotheaptid,
-							  BTreeTupleGetHeapTID(firstright)) < 0);
-#endif
-
-	return tidpivot;
-}
-
-/*
- * _bt_keep_natts - how many key attributes to keep when truncating.
- *
- * Caller provides two tuples that enclose a split point.  Caller's insertion
- * scankey is used to compare the tuples; the scankey's argument values are
- * not considered here.
- *
- * This can return a number of attributes that is one greater than the
- * number of key attributes for the index relation.  This indicates that the
- * caller must use a heap TID as a unique-ifier in new pivot tuple.
- */
-static int
-_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
-			   BTScanInsert itup_key)
-{
-	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keepnatts;
-	ScanKey		scankey;
-
-	/*
-	 * _bt_compare() treats truncated key attributes as having the value minus
-	 * infinity, which would break searches within !heapkeyspace indexes.  We
-	 * must still truncate away non-key attribute values, though.
-	 */
-	if (!itup_key->heapkeyspace)
-		return nkeyatts;
-
-	scankey = itup_key->scankeys;
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
-											scankey->sk_collation,
-											datum1,
-											datum2)) != 0)
-			break;
-
-		keepnatts++;
-	}
-
-	/*
-	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
-	 * expected in an allequalimage index.
-	 */
-	Assert(!itup_key->allequalimage ||
-		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
-
-	return keepnatts;
-}
-
-/*
- * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
- *
- * This is exported so that a candidate split point can have its effect on
- * suffix truncation inexpensively evaluated ahead of time when finding a
- * split location.  A naive bitwise approach to datum comparisons is used to
- * save cycles.
- *
- * The approach taken here usually provides the same answer as _bt_keep_natts
- * will (for the same pair of tuples from a heapkeyspace index), since the
- * majority of btree opclasses can never indicate that two datums are equal
- * unless they're bitwise equal after detoasting.  When an index only has
- * "equal image" columns, routine is guaranteed to give the same result as
- * _bt_keep_natts would.
- *
- * Callers can rely on the fact that attributes considered equal here are
- * definitely also equal according to _bt_keep_natts, even when the index uses
- * an opclass or collation that is not "allequalimage"/deduplication-safe.
- * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
- * negatives generally only have the effect of making leaf page splits use a
- * more balanced split point.
- */
-int
-_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
-{
-	TupleDesc	itupdesc = RelationGetDescr(rel);
-	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
-	int			keepnatts;
-
-	keepnatts = 1;
-	for (int attnum = 1; attnum <= keysz; attnum++)
-	{
-		Datum		datum1,
-					datum2;
-		bool		isNull1,
-					isNull2;
-		Form_pg_attribute att;
-
-		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
-		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
-		att = TupleDescAttr(itupdesc, attnum - 1);
-
-		if (isNull1 != isNull2)
-			break;
-
-		if (!isNull1 &&
-			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
-			break;
-
-		keepnatts++;
-	}
-
-	return keepnatts;
-}
-
 /*
  *  _bt_check_natts() -- Verify tuple has expected number of attributes.
  *
diff --git a/src/backend/access/nbtree/nbtutils_spec.c b/src/backend/access/nbtree/nbtutils_spec.c
new file mode 100644
index 0000000000..29a9ce3664
--- /dev/null
+++ b/src/backend/access/nbtree/nbtutils_spec.c
@@ -0,0 +1,809 @@
+/*-------------------------------------------------------------------------
+ *
+ * nbtutils_spec.c
+ *	  Index shape-specialized functions for nbtutils.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/nbtutils_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static bool _bt_check_rowcompare(ScanKey skey,
+								 IndexTuple tuple, int tupnatts, TupleDesc tupdesc,
+								 ScanDirection dir, bool *continuescan);
+static int	_bt_keep_natts(Relation rel, IndexTuple lastleft,
+							 IndexTuple firstright, BTScanInsert itup_key);
+
+
+/*
+ * _bt_mkscankey
+ *		Build an insertion scan key that contains comparison data from itup
+ *		as well as comparator routines appropriate to the key datatypes.
+ *
+ *		The result is intended for use with _bt_compare() and _bt_truncate().
+ *		Callers that don't need to fill out the insertion scankey arguments
+ *		(e.g. they use an ad-hoc comparison routine, or only need a scankey
+ *		for _bt_truncate()) can pass a NULL index tuple.  The scankey will
+ *		be initialized as if an "all truncated" pivot tuple was passed
+ *		instead.
+ *
+ *		Note that we may occasionally have to share lock the metapage to
+ *		determine whether or not the keys in the index are expected to be
+ *		unique (i.e. if this is a "heapkeyspace" index).  We assume a
+ *		heapkeyspace index when caller passes a NULL tuple, allowing index
+ *		build callers to avoid accessing the non-existent metapage.  We
+ *		also assume that the index is _not_ allequalimage when a NULL tuple
+ *		is passed; CREATE INDEX callers call _bt_allequalimage() to set the
+ *		field themselves.
+ */
+BTScanInsert
+_bt_mkscankey(Relation rel, IndexTuple itup)
+{
+	BTScanInsert key;
+	ScanKey		skey;
+	TupleDesc	itupdesc;
+	int			indnkeyatts;
+	int16	   *indoption;
+	int			tupnatts;
+	int			i;
+
+	itupdesc = RelationGetDescr(rel);
+	indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	indoption = rel->rd_indoption;
+	tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
+
+	Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
+
+	/*
+	 * We'll execute search using scan key constructed on key columns.
+	 * Truncated attributes and non-key attributes are omitted from the final
+	 * scan key.
+	 */
+	key = palloc(offsetof(BTScanInsertData, scankeys) +
+				 sizeof(ScanKeyData) * indnkeyatts);
+	if (itup)
+		_bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
+	else
+	{
+		/* Utility statement callers can set these fields themselves */
+		key->heapkeyspace = true;
+		key->allequalimage = false;
+	}
+	key->anynullkeys = false;	/* initial assumption */
+	key->nextkey = false;		/* usual case, required by btinsert */
+	key->backward = false;		/* usual case, required by btinsert */
+	key->keysz = Min(indnkeyatts, tupnatts);
+	key->scantid = key->heapkeyspace && itup ?
+		BTreeTupleGetHeapTID(itup) : NULL;
+	skey = key->scankeys;
+	for (i = 0; i < indnkeyatts; i++)
+	{
+		FmgrInfo   *procinfo;
+		Datum		arg;
+		bool		null;
+		int			flags;
+
+		/*
+		 * We can use the cached (default) support procs since no cross-type
+		 * comparison can be needed.
+		 */
+		procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
+
+		/*
+		 * Key arguments built from truncated attributes (or when caller
+		 * provides no tuple) are defensively represented as NULL values. They
+		 * should never be used.
+		 */
+		if (i < tupnatts)
+			arg = index_getattr(itup, i + 1, itupdesc, &null);
+		else
+		{
+			arg = (Datum) 0;
+			null = true;
+		}
+		flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
+		ScanKeyEntryInitializeWithInfo(&skey[i],
+									   flags,
+									   (AttrNumber) (i + 1),
+									   InvalidStrategy,
+									   InvalidOid,
+									   rel->rd_indcollation[i],
+									   procinfo,
+									   arg);
+		/* Record if any key attribute is NULL (or truncated) */
+		if (null)
+			key->anynullkeys = true;
+	}
+
+	/*
+	 * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
+	 * that full uniqueness check is done.
+	 */
+	if (rel->rd_index->indnullsnotdistinct)
+		key->anynullkeys = false;
+
+	return key;
+}
+
+/*
+ * Test whether an indextuple satisfies all the scankey conditions.
+ *
+ * Return true if so, false if not.  If the tuple fails to pass the qual,
+ * we also determine whether there's any need to continue the scan beyond
+ * this tuple, and set *continuescan accordingly.  See comments for
+ * _bt_preprocess_keys(), above, about how this is done.
+ *
+ * Forward scan callers can pass a high key tuple in the hopes of having
+ * us set *continuescan to false, and avoiding an unnecessary visit to
+ * the page to the right.
+ *
+ * scan: index scan descriptor (containing a search-type scankey)
+ * tuple: index tuple to test
+ * tupnatts: number of attributes in tupnatts (high key may be truncated)
+ * dir: direction we are scanning in
+ * continuescan: output parameter (will be set correctly in all cases)
+ * continuescanPrechecked: indicates that *continuescan flag is known to
+ * 						   be true for the last item on the page
+ * haveFirstMatch: indicates that we already have at least one match
+ * 							  in the current page
+ */
+bool
+_bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+			  ScanDirection dir, bool *continuescan,
+			  bool continuescanPrechecked, bool haveFirstMatch)
+{
+	TupleDesc	tupdesc;
+	BTScanOpaque so;
+	int			keysz;
+	int			ikey;
+	ScanKey		key;
+
+	Assert(BTreeTupleGetNAtts(tuple, scan->indexRelation) == tupnatts);
+
+	*continuescan = true;		/* default assumption */
+
+	tupdesc = RelationGetDescr(scan->indexRelation);
+	so = (BTScanOpaque) scan->opaque;
+	keysz = so->numberOfKeys;
+
+	for (key = so->keyData, ikey = 0; ikey < keysz; key++, ikey++)
+	{
+		Datum		datum;
+		bool		isNull;
+		Datum		test;
+		bool		requiredSameDir = false,
+					requiredOppositeDir = false;
+
+		/*
+		 * Check if the key is required for ordered scan in the same or
+		 * opposite direction.  Save as flag variables for future usage.
+		 */
+		if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsForward(dir)) ||
+			((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsBackward(dir)))
+			requiredSameDir = true;
+		else if (((key->sk_flags & SK_BT_REQFWD) && ScanDirectionIsBackward(dir)) ||
+				 ((key->sk_flags & SK_BT_REQBKWD) && ScanDirectionIsForward(dir)))
+			requiredOppositeDir = true;
+
+		/*
+		 * If the caller told us the *continuescan flag is known to be true
+		 * for the last item on the page, then we know the keys required for
+		 * the current direction scan should be matched.  Otherwise, the
+		 * *continuescan flag would be set for the current item and
+		 * subsequently the last item on the page accordingly.
+		 *
+		 * If the key is required for the opposite direction scan, we can skip
+		 * the check if the caller tells us there was already at least one
+		 * matching item on the page. Also, we require the *continuescan flag
+		 * to be true for the last item on the page to know there are no
+		 * NULLs.
+		 *
+		 * Both cases above work except for the row keys, where NULLs could be
+		 * found in the middle of matching values.
+		 */
+		if ((requiredSameDir || (requiredOppositeDir && haveFirstMatch)) &&
+			!(key->sk_flags & SK_ROW_HEADER) && continuescanPrechecked)
+			continue;
+
+		if (key->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			continue;
+		}
+
+		/* row-comparison keys need special processing */
+		if (key->sk_flags & SK_ROW_HEADER)
+		{
+			if (_bt_check_rowcompare(key, tuple, tupnatts, tupdesc, dir,
+									 continuescan))
+				continue;
+			return false;
+		}
+
+		datum = index_getattr(tuple,
+							  key->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (key->sk_flags & SK_ISNULL)
+		{
+			/* Handle IS NULL/NOT NULL tests */
+			if (key->sk_flags & SK_SEARCHNULL)
+			{
+				if (isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+			else
+			{
+				Assert(key->sk_flags & SK_SEARCHNOTNULL);
+				if (!isNull)
+					continue;	/* tuple satisfies this qual */
+			}
+
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 */
+			if (requiredSameDir)
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (isNull)
+		{
+			if (key->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((key->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		/*
+		 * Apply the key-checking function.  When the key is required for the
+		 * opposite direction scan, it must be already satisfied as soon as
+		 * there is already match on the page.  Except for the NULLs checking,
+		 * which have already done above.
+		 */
+		if (!(requiredOppositeDir && haveFirstMatch))
+		{
+			test = FunctionCall2Coll(&key->sk_func, key->sk_collation,
+									 datum, key->sk_argument);
+		}
+		else
+		{
+			test = true;
+			Assert(test == FunctionCall2Coll(&key->sk_func, key->sk_collation,
+											 datum, key->sk_argument));
+		}
+
+		if (!DatumGetBool(test))
+		{
+			/*
+			 * Tuple fails this qual.  If it's a required qual for the current
+			 * scan direction, then we can conclude no further tuples will
+			 * pass, either.
+			 *
+			 * Note: because we stop the scan as soon as any required equality
+			 * qual fails, it is critical that equality quals be used for the
+			 * initial positioning in _bt_first() when they are available. See
+			 * comments in _bt_first().
+			 */
+			if (requiredSameDir)
+				*continuescan = false;
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+	}
+
+	/* If we get here, the tuple passes all index quals. */
+	return true;
+}
+
+/*
+ * Test whether an indextuple satisfies a row-comparison scan condition.
+ *
+ * Return true if so, false if not.  If not, also clear *continuescan if
+ * it's not possible for any future tuples in the current scan direction
+ * to pass the qual.
+ *
+ * This is a subroutine for _bt_checkkeys, which see for more info.
+ */
+static bool
+_bt_check_rowcompare(ScanKey skey, IndexTuple tuple, int tupnatts,
+					 TupleDesc tupdesc, ScanDirection dir, bool *continuescan)
+{
+	ScanKey		subkey = (ScanKey) DatumGetPointer(skey->sk_argument);
+	int32		cmpresult = 0;
+	bool		result;
+
+	/* First subkey should be same as the header says */
+	Assert(subkey->sk_attno == skey->sk_attno);
+
+	/* Loop over columns of the row condition */
+	for (;;)
+	{
+		Datum		datum;
+		bool		isNull;
+
+		Assert(subkey->sk_flags & SK_ROW_MEMBER);
+
+		if (subkey->sk_attno > tupnatts)
+		{
+			/*
+			 * This attribute is truncated (must be high key).  The value for
+			 * this attribute in the first non-pivot tuple on the page to the
+			 * right could be any possible value.  Assume that truncated
+			 * attribute passes the qual.
+			 */
+			Assert(ScanDirectionIsForward(dir));
+			Assert(BTreeTupleIsPivot(tuple));
+			cmpresult = 0;
+			if (subkey->sk_flags & SK_ROW_END)
+				break;
+			subkey++;
+			continue;
+		}
+
+		datum = index_getattr(tuple,
+							  subkey->sk_attno,
+							  tupdesc,
+							  &isNull);
+
+		if (isNull)
+		{
+			if (subkey->sk_flags & SK_BT_NULLS_FIRST)
+			{
+				/*
+				 * Since NULLs are sorted before non-NULLs, we know we have
+				 * reached the lower limit of the range of values for this
+				 * index attr.  On a backward scan, we can stop if this qual
+				 * is one of the "must match" subset.  We can stop regardless
+				 * of whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a forward scan, however, we must keep going, because we may
+				 * have initially positioned to the start of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsBackward(dir))
+					*continuescan = false;
+			}
+			else
+			{
+				/*
+				 * Since NULLs are sorted after non-NULLs, we know we have
+				 * reached the upper limit of the range of values for this
+				 * index attr.  On a forward scan, we can stop if this qual is
+				 * one of the "must match" subset.  We can stop regardless of
+				 * whether the qual is > or <, so long as it's required,
+				 * because it's not possible for any future tuples to pass. On
+				 * a backward scan, however, we must keep going, because we
+				 * may have initially positioned to the end of the index.
+				 */
+				if ((subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)) &&
+					ScanDirectionIsForward(dir))
+					*continuescan = false;
+			}
+
+			/*
+			 * In any case, this indextuple doesn't match the qual.
+			 */
+			return false;
+		}
+
+		if (subkey->sk_flags & SK_ISNULL)
+		{
+			/*
+			 * Unlike the simple-scankey case, this isn't a disallowed case.
+			 * But it can never match.  If all the earlier row comparison
+			 * columns are required for the scan direction, we can stop the
+			 * scan, because there can't be another tuple that will succeed.
+			 */
+			if (subkey != (ScanKey) DatumGetPointer(skey->sk_argument))
+				subkey--;
+			if ((subkey->sk_flags & SK_BT_REQFWD) &&
+				ScanDirectionIsForward(dir))
+				*continuescan = false;
+			else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+					 ScanDirectionIsBackward(dir))
+				*continuescan = false;
+			return false;
+		}
+
+		/* Perform the test --- three-way comparison not bool operator */
+		cmpresult = DatumGetInt32(FunctionCall2Coll(&subkey->sk_func,
+													subkey->sk_collation,
+													datum,
+													subkey->sk_argument));
+
+		if (subkey->sk_flags & SK_BT_DESC)
+			INVERT_COMPARE_RESULT(cmpresult);
+
+		/* Done comparing if unequal, else advance to next column */
+		if (cmpresult != 0)
+			break;
+
+		if (subkey->sk_flags & SK_ROW_END)
+			break;
+		subkey++;
+	}
+
+	/*
+	 * At this point cmpresult indicates the overall result of the row
+	 * comparison, and subkey points to the deciding column (or the last
+	 * column if the result is "=").
+	 */
+	switch (subkey->sk_strategy)
+	{
+			/* EQ and NE cases aren't allowed here */
+		case BTLessStrategyNumber:
+			result = (cmpresult < 0);
+			break;
+		case BTLessEqualStrategyNumber:
+			result = (cmpresult <= 0);
+			break;
+		case BTGreaterEqualStrategyNumber:
+			result = (cmpresult >= 0);
+			break;
+		case BTGreaterStrategyNumber:
+			result = (cmpresult > 0);
+			break;
+		default:
+			elog(ERROR, "unrecognized RowCompareType: %d",
+				 (int) subkey->sk_strategy);
+			result = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	if (!result)
+	{
+		/*
+		 * Tuple fails this qual.  If it's a required qual for the current
+		 * scan direction, then we can conclude no further tuples will pass,
+		 * either.  Note we have to look at the deciding column, not
+		 * necessarily the first or last column of the row condition.
+		 */
+		if ((subkey->sk_flags & SK_BT_REQFWD) &&
+			ScanDirectionIsForward(dir))
+			*continuescan = false;
+		else if ((subkey->sk_flags & SK_BT_REQBKWD) &&
+				 ScanDirectionIsBackward(dir))
+			*continuescan = false;
+	}
+
+	return result;
+}
+
+/*
+ *	_bt_truncate() -- create tuple without unneeded suffix attributes.
+ *
+ * Returns truncated pivot index tuple allocated in caller's memory context,
+ * with key attributes copied from caller's firstright argument.  If rel is
+ * an INCLUDE index, non-key attributes will definitely be truncated away,
+ * since they're not part of the key space.  More aggressive suffix
+ * truncation can take place when it's clear that the returned tuple does not
+ * need one or more suffix key attributes.  We only need to keep firstright
+ * attributes up to and including the first non-lastleft-equal attribute.
+ * Caller's insertion scankey is used to compare the tuples; the scankey's
+ * argument values are not considered here.
+ *
+ * Note that returned tuple's t_tid offset will hold the number of attributes
+ * present, so the original item pointer offset is not represented.  Caller
+ * should only change truncated tuple's downlink.  Note also that truncated
+ * key attributes are treated as containing "minus infinity" values by
+ * _bt_compare().
+ *
+ * In the worst case (when a heap TID must be appended to distinguish lastleft
+ * from firstright), the size of the returned tuple is the size of firstright
+ * plus the size of an additional MAXALIGN()'d item pointer.  This guarantee
+ * is important, since callers need to stay under the 1/3 of a page
+ * restriction on tuple size.  If this routine is ever taught to truncate
+ * within an attribute/datum, it will need to avoid returning an enlarged
+ * tuple to caller when truncation + TOAST compression ends up enlarging the
+ * final datum.
+ */
+IndexTuple
+_bt_truncate(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			 BTScanInsert itup_key)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int16		nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+	IndexTuple	pivot;
+	IndexTuple	tidpivot;
+	ItemPointer pivotheaptid;
+	Size		newsize;
+
+	/*
+	 * We should only ever truncate non-pivot tuples from leaf pages.  It's
+	 * never okay to truncate when splitting an internal page.
+	 */
+	Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
+
+	/* Determine how many attributes must be kept in truncated tuple */
+	keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
+
+#ifdef DEBUG_NO_TRUNCATE
+	/* Force truncation to be ineffective for testing purposes */
+	keepnatts = nkeyatts + 1;
+#endif
+
+	pivot = index_truncate_tuple(itupdesc, firstright,
+								 Min(keepnatts, nkeyatts));
+
+	if (BTreeTupleIsPosting(pivot))
+	{
+		/*
+		 * index_truncate_tuple() just returns a straight copy of firstright
+		 * when it has no attributes to truncate.  When that happens, we may
+		 * need to truncate away a posting list here instead.
+		 */
+		Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
+		Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
+		pivot->t_info &= ~INDEX_SIZE_MASK;
+		pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
+	}
+
+	/*
+	 * If there is a distinguishing key attribute within pivot tuple, we're
+	 * done
+	 */
+	if (keepnatts <= nkeyatts)
+	{
+		BTreeTupleSetNAtts(pivot, keepnatts, false);
+		return pivot;
+	}
+
+	/*
+	 * We have to store a heap TID in the new pivot tuple, since no non-TID
+	 * key attribute value in firstright distinguishes the right side of the
+	 * split from the left side.  nbtree conceptualizes this case as an
+	 * inability to truncate away any key attributes, since heap TID is
+	 * treated as just another key attribute (despite lacking a pg_attribute
+	 * entry).
+	 *
+	 * Use enlarged space that holds a copy of pivot.  We need the extra space
+	 * to store a heap TID at the end (using the special pivot tuple
+	 * representation).  Note that the original pivot already has firstright's
+	 * possible posting list/non-key attribute values removed at this point.
+	 */
+	newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
+	tidpivot = palloc0(newsize);
+	memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
+	/* Cannot leak memory here */
+	pfree(pivot);
+
+	/*
+	 * Store all of firstright's key attribute values plus a tiebreaker heap
+	 * TID value in enlarged pivot tuple
+	 */
+	tidpivot->t_info &= ~INDEX_SIZE_MASK;
+	tidpivot->t_info |= newsize;
+	BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
+	pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
+
+	/*
+	 * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
+	 * consider suffix truncation.  It seems like a good idea to follow that
+	 * example in cases where no truncation takes place -- use lastleft's heap
+	 * TID.  (This is also the closest value to negative infinity that's
+	 * legally usable.)
+	 */
+	ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
+
+	/*
+	 * We're done.  Assert() that heap TID invariants hold before returning.
+	 *
+	 * Lehman and Yao require that the downlink to the right page, which is to
+	 * be inserted into the parent page in the second phase of a page split be
+	 * a strict lower bound on items on the right page, and a non-strict upper
+	 * bound for items on the left page.  Assert that heap TIDs follow these
+	 * invariants, since a heap TID value is apparently needed as a
+	 * tiebreaker.
+	 */
+#ifndef DEBUG_NO_TRUNCATE
+	Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(lastleft)) >= 0);
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#else
+
+	/*
+	 * Those invariants aren't guaranteed to hold for lastleft + firstright
+	 * heap TID attribute values when they're considered here only because
+	 * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
+	 * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
+	 * TID value that always works as a strict lower bound for items to the
+	 * right.  In particular, it must avoid using firstright's leading key
+	 * attribute values along with lastleft's heap TID value when lastleft's
+	 * TID happens to be greater than firstright's TID.
+	 */
+	ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
+
+	/*
+	 * Pivot heap TID should never be fully equal to firstright.  Note that
+	 * the pivot heap TID will still end up equal to lastleft's heap TID when
+	 * that's the only usable value.
+	 */
+	ItemPointerSetOffsetNumber(pivotheaptid,
+							   OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
+	Assert(ItemPointerCompare(pivotheaptid,
+							  BTreeTupleGetHeapTID(firstright)) < 0);
+#endif
+
+	return tidpivot;
+}
+
+/*
+ * _bt_keep_natts - how many key attributes to keep when truncating.
+ *
+ * Caller provides two tuples that enclose a split point.  Caller's insertion
+ * scankey is used to compare the tuples; the scankey's argument values are
+ * not considered here.
+ *
+ * This can return a number of attributes that is one greater than the
+ * number of key attributes for the index relation.  This indicates that the
+ * caller must use a heap TID as a unique-ifier in new pivot tuple.
+ */
+static int
+_bt_keep_natts(Relation rel, IndexTuple lastleft, IndexTuple firstright,
+			   BTScanInsert itup_key)
+{
+	int			nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keepnatts;
+	ScanKey		scankey;
+
+	/*
+	 * _bt_compare() treats truncated key attributes as having the value minus
+	 * infinity, which would break searches within !heapkeyspace indexes.  We
+	 * must still truncate away non-key attribute values, though.
+	 */
+	if (!itup_key->heapkeyspace)
+		return nkeyatts;
+
+	scankey = itup_key->scankeys;
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= nkeyatts; attnum++, scankey++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
+											scankey->sk_collation,
+											datum1,
+											datum2)) != 0)
+			break;
+
+		keepnatts++;
+	}
+
+	/*
+	 * Assert that _bt_keep_natts_fast() agrees with us in passing.  This is
+	 * expected in an allequalimage index.
+	 */
+	Assert(!itup_key->allequalimage ||
+		   keepnatts == _bt_keep_natts_fast(rel, lastleft, firstright));
+
+	return keepnatts;
+}
+
+/*
+ * _bt_keep_natts_fast - fast bitwise variant of _bt_keep_natts.
+ *
+ * This is exported so that a candidate split point can have its effect on
+ * suffix truncation inexpensively evaluated ahead of time when finding a
+ * split location.  A naive bitwise approach to datum comparisons is used to
+ * save cycles.
+ *
+ * The approach taken here usually provides the same answer as _bt_keep_natts
+ * will (for the same pair of tuples from a heapkeyspace index), since the
+ * majority of btree opclasses can never indicate that two datums are equal
+ * unless they're bitwise equal after detoasting.  When an index only has
+ * "equal image" columns, routine is guaranteed to give the same result as
+ * _bt_keep_natts would.
+ *
+ * Callers can rely on the fact that attributes considered equal here are
+ * definitely also equal according to _bt_keep_natts, even when the index uses
+ * an opclass or collation that is not "allequalimage"/deduplication-safe.
+ * This weaker guarantee is good enough for nbtsplitloc.c caller, since false
+ * negatives generally only have the effect of making leaf page splits use a
+ * more balanced split point.
+ */
+int
+_bt_keep_natts_fast(Relation rel, IndexTuple lastleft, IndexTuple firstright)
+{
+	TupleDesc	itupdesc = RelationGetDescr(rel);
+	int			keysz = IndexRelationGetNumberOfKeyAttributes(rel);
+	int			keepnatts;
+
+	keepnatts = 1;
+	for (int attnum = 1; attnum <= keysz; attnum++)
+	{
+		Datum		datum1,
+					datum2;
+		bool		isNull1,
+					isNull2;
+		Form_pg_attribute att;
+
+		datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
+		datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
+		att = TupleDescAttr(itupdesc, attnum - 1);
+
+		if (isNull1 != isNull2)
+			break;
+
+		if (!isNull1 &&
+			!datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
+			break;
+
+		keepnatts++;
+	}
+
+	return keepnatts;
+}
diff --git a/src/backend/utils/sort/tuplesortvariants.c b/src/backend/utils/sort/tuplesortvariants.c
index 08f9f16262..6da7d7fd58 100644
--- a/src/backend/utils/sort/tuplesortvariants.c
+++ b/src/backend/utils/sort/tuplesortvariants.c
@@ -64,10 +64,6 @@ static void writetup_cluster(Tuplesortstate *state, LogicalTape *tape,
 							 SortTuple *stup);
 static void readtup_cluster(Tuplesortstate *state, SortTuple *stup,
 							LogicalTape *tape, unsigned int tuplen);
-static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-								   Tuplesortstate *state);
-static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
-											Tuplesortstate *state);
 static int	comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 								  Tuplesortstate *state);
 static int	comparetup_index_hash_tiebreak(const SortTuple *a, const SortTuple *b,
@@ -163,6 +159,7 @@ typedef struct BrinSortTuple
 /* Size of the BrinSortTuple, given length of the BrinTuple. */
 #define BRINSORTTUPLE_SIZE(len)		(offsetof(BrinSortTuple, tuple) + (len))
 
+#include "tuplesortvariants_spec.c"
 
 Tuplesortstate *
 tuplesort_begin_heap(TupleDesc tupDesc,
@@ -1410,152 +1407,6 @@ removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
 	}
 }
 
-static int
-comparetup_index_btree(const SortTuple *a, const SortTuple *b,
-					   Tuplesortstate *state)
-{
-	/*
-	 * This is similar to comparetup_heap(), but expects index tuples.  There
-	 * is also special handling for enforcing uniqueness, and special
-	 * treatment for equal keys at the end.
-	 */
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	SortSupport sortKey = base->sortKeys;
-	int32		compare;
-
-	/* Compare the leading sort key */
-	compare = ApplySortComparator(a->datum1, a->isnull1,
-								  b->datum1, b->isnull1,
-								  sortKey);
-	if (compare != 0)
-		return compare;
-
-	/* Compare additional sort keys */
-	return comparetup_index_btree_tiebreak(a, b, state);
-}
-
-static int
-comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
-								Tuplesortstate *state)
-{
-	TuplesortPublic *base = TuplesortstateGetPublic(state);
-	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
-	SortSupport sortKey = base->sortKeys;
-	IndexTuple	tuple1;
-	IndexTuple	tuple2;
-	int			keysz;
-	TupleDesc	tupDes;
-	bool		equal_hasnull = false;
-	int			nkey;
-	int32		compare;
-	Datum		datum1,
-				datum2;
-	bool		isnull1,
-				isnull2;
-
-	tuple1 = (IndexTuple) a->tuple;
-	tuple2 = (IndexTuple) b->tuple;
-	keysz = base->nKeys;
-	tupDes = RelationGetDescr(arg->index.indexRel);
-
-	if (sortKey->abbrev_converter)
-	{
-		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
-
-		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
-												datum2, isnull2,
-												sortKey);
-		if (compare != 0)
-			return compare;
-	}
-
-	/* they are equal, so we only need to examine one null flag */
-	if (a->isnull1)
-		equal_hasnull = true;
-
-	sortKey++;
-	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
-	{
-		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
-		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
-
-		compare = ApplySortComparator(datum1, isnull1,
-									  datum2, isnull2,
-									  sortKey);
-		if (compare != 0)
-			return compare;		/* done when we find unequal attributes */
-
-		/* they are equal, so we only need to examine one null flag */
-		if (isnull1)
-			equal_hasnull = true;
-	}
-
-	/*
-	 * If btree has asked us to enforce uniqueness, complain if two equal
-	 * tuples are detected (unless there was at least one NULL field and NULLS
-	 * NOT DISTINCT was not set).
-	 *
-	 * It is sufficient to make the test here, because if two tuples are equal
-	 * they *must* get compared at some stage of the sort --- otherwise the
-	 * sort algorithm wouldn't have checked whether one must appear before the
-	 * other.
-	 */
-	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
-	{
-		Datum		values[INDEX_MAX_KEYS];
-		bool		isnull[INDEX_MAX_KEYS];
-		char	   *key_desc;
-
-		/*
-		 * Some rather brain-dead implementations of qsort (such as the one in
-		 * QNX 4) will sometimes call the comparison routine to compare a
-		 * value to itself, but we always use our own implementation, which
-		 * does not.
-		 */
-		Assert(tuple1 != tuple2);
-
-		index_deform_tuple(tuple1, tupDes, values, isnull);
-
-		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
-
-		ereport(ERROR,
-				(errcode(ERRCODE_UNIQUE_VIOLATION),
-				 errmsg("could not create unique index \"%s\"",
-						RelationGetRelationName(arg->index.indexRel)),
-				 key_desc ? errdetail("Key %s is duplicated.", key_desc) :
-				 errdetail("Duplicate keys exist."),
-				 errtableconstraint(arg->index.heapRel,
-									RelationGetRelationName(arg->index.indexRel))));
-	}
-
-	/*
-	 * If key values are equal, we sort on ItemPointer.  This is required for
-	 * btree indexes, since heap TID is treated as an implicit last key
-	 * attribute in order to ensure that all keys in the index are physically
-	 * unique.
-	 */
-	{
-		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
-		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
-
-		if (blk1 != blk2)
-			return (blk1 < blk2) ? -1 : 1;
-	}
-	{
-		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
-		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
-
-		if (pos1 != pos2)
-			return (pos1 < pos2) ? -1 : 1;
-	}
-
-	/* ItemPointer values should never be equal */
-	Assert(false);
-
-	return 0;
-}
-
 static int
 comparetup_index_hash(const SortTuple *a, const SortTuple *b,
 					  Tuplesortstate *state)
diff --git a/src/backend/utils/sort/tuplesortvariants_spec.c b/src/backend/utils/sort/tuplesortvariants_spec.c
new file mode 100644
index 0000000000..76cabb207e
--- /dev/null
+++ b/src/backend/utils/sort/tuplesortvariants_spec.c
@@ -0,0 +1,172 @@
+/*-------------------------------------------------------------------------
+ *
+ * tuplesortvariants_spec.c
+ *	  Index shape-specialized functions for tuplesortvariants.c
+ *
+ * NOTES
+ *	  See also: access/nbtree/README section "nbtree specialization"
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/access/nbtree/tuplesortvariants_spec.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static int	comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+								   Tuplesortstate *state);
+static int	comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
+											Tuplesortstate *state);
+
+static int
+comparetup_index_btree(const SortTuple *a, const SortTuple *b,
+					   Tuplesortstate *state)
+{
+	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	SortSupport sortKey = base->sortKeys;
+	int32		compare;
+
+	/* Compare the leading sort key */
+	compare = ApplySortComparator(a->datum1, a->isnull1,
+								  b->datum1, b->isnull1,
+								  sortKey);
+	if (compare != 0)
+		return compare;
+
+	/* Compare additional sort keys */
+	return comparetup_index_btree_tiebreak(a, b, state);
+}
+
+static int
+comparetup_index_btree_tiebreak(const SortTuple *a, const SortTuple *b,
+								Tuplesortstate *state)
+{	/*
+	 * This is similar to comparetup_heap(), but expects index tuples.  There
+	 * is also special handling for enforcing uniqueness, and special
+	 * treatment for equal keys at the end.
+	 */
+	TuplesortPublic *base = TuplesortstateGetPublic(state);
+	TuplesortIndexBTreeArg *arg = (TuplesortIndexBTreeArg *) base->arg;
+	SortSupport sortKey = base->sortKeys;
+	IndexTuple	tuple1;
+	IndexTuple	tuple2;
+	int			keysz;
+	TupleDesc	tupDes;
+	bool		equal_hasnull = false;
+	int			nkey;
+	int32		compare;
+	Datum		datum1,
+				datum2;
+	bool		isnull1,
+				isnull2;
+
+	tuple1 = (IndexTuple) a->tuple;
+	tuple2 = (IndexTuple) b->tuple;
+	keysz = base->nKeys;
+	tupDes = RelationGetDescr(arg->index.indexRel);
+
+	if (sortKey->abbrev_converter)
+	{
+		datum1 = index_getattr(tuple1, 1, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, 1, tupDes, &isnull2);
+
+		compare = ApplySortAbbrevFullComparator(datum1, isnull1,
+												datum2, isnull2,
+												sortKey);
+		if (compare != 0)
+			return compare;
+	}
+
+	/* they are equal, so we only need to examine one null flag */
+	if (a->isnull1)
+		equal_hasnull = true;
+
+	sortKey++;
+	for (nkey = 2; nkey <= keysz; nkey++, sortKey++)
+	{
+		datum1 = index_getattr(tuple1, nkey, tupDes, &isnull1);
+		datum2 = index_getattr(tuple2, nkey, tupDes, &isnull2);
+
+		compare = ApplySortComparator(datum1, isnull1,
+									  datum2, isnull2,
+									  sortKey);
+		if (compare != 0)
+			return compare;		/* done when we find unequal attributes */
+
+		/* they are equal, so we only need to examine one null flag */
+		if (isnull1)
+			equal_hasnull = true;
+	}
+
+	/*
+	 * If btree has asked us to enforce uniqueness, complain if two equal
+	 * tuples are detected (unless there was at least one NULL field and NULLS
+	 * NOT DISTINCT was not set).
+	 *
+	 * It is sufficient to make the test here, because if two tuples are equal
+	 * they *must* get compared at some stage of the sort --- otherwise the
+	 * sort algorithm wouldn't have checked whether one must appear before the
+	 * other.
+	 */
+	if (arg->enforceUnique && !(!arg->uniqueNullsNotDistinct && equal_hasnull))
+	{
+		Datum		values[INDEX_MAX_KEYS];
+		bool		isnull[INDEX_MAX_KEYS];
+		char	   *key_desc;
+
+		/*
+		 * Some rather brain-dead implementations of qsort (such as the one in
+		 * QNX 4) will sometimes call the comparison routine to compare a
+		 * value to itself, but we always use our own implementation, which
+		 * does not.
+		 */
+		Assert(tuple1 != tuple2);
+
+		index_deform_tuple(tuple1, tupDes, values, isnull);
+
+		key_desc = BuildIndexValueDescription(arg->index.indexRel, values, isnull);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_UNIQUE_VIOLATION),
+					errmsg("could not create unique index \"%s\"",
+						   RelationGetRelationName(arg->index.indexRel)),
+					key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+					errdetail("Duplicate keys exist."),
+					errtableconstraint(arg->index.heapRel,
+									   RelationGetRelationName(arg->index.indexRel))));
+	}
+
+	/*
+	 * If key values are equal, we sort on ItemPointer.  This is required for
+	 * btree indexes, since heap TID is treated as an implicit last key
+	 * attribute in order to ensure that all keys in the index are physically
+	 * unique.
+	 */
+	{
+		BlockNumber blk1 = ItemPointerGetBlockNumber(&tuple1->t_tid);
+		BlockNumber blk2 = ItemPointerGetBlockNumber(&tuple2->t_tid);
+
+		if (blk1 != blk2)
+			return (blk1 < blk2) ? -1 : 1;
+	}
+	{
+		OffsetNumber pos1 = ItemPointerGetOffsetNumber(&tuple1->t_tid);
+		OffsetNumber pos2 = ItemPointerGetOffsetNumber(&tuple2->t_tid);
+
+		if (pos1 != pos2)
+			return (pos1 < pos2) ? -1 : 1;
+	}
+
+	/* ItemPointer values should never be equal */
+	Assert(false);
+
+	return 0;
+}
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 6eb162052e..63e245dcbc 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -1118,15 +1118,12 @@ typedef struct BTOptions
 #define PROGRESS_BTREE_PHASE_PERFORMSORT_2				4
 #define PROGRESS_BTREE_PHASE_LEAF_LOAD					5
 
+#include "access/nbtree_specfuncs.h"
+
 /*
  * external entry points for btree, in nbtree.c
  */
 extern void btbuildempty(Relation index);
-extern bool btinsert(Relation rel, Datum *values, bool *isnull,
-					 ItemPointer ht_ctid, Relation heapRel,
-					 IndexUniqueCheck checkUnique,
-					 bool indexUnchanged,
-					 struct IndexInfo *indexInfo);
 extern IndexScanDesc btbeginscan(Relation rel, int nkeys, int norderbys);
 extern Size btestimateparallelscan(void);
 extern void btinitparallelscan(void *target);
@@ -1157,8 +1154,6 @@ extern void _bt_parallel_advance_array_keys(IndexScanDesc scan);
 /*
  * prototypes for functions in nbtdedup.c
  */
-extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
-						   Size newitemsz, bool bottomupdedup);
 extern bool _bt_bottomupdel_pass(Relation rel, Buffer buf, Relation heapRel,
 								 Size newitemsz);
 extern void _bt_dedup_start_pending(BTDedupState state, IndexTuple base,
@@ -1174,9 +1169,6 @@ extern IndexTuple _bt_swap_posting(IndexTuple newitem, IndexTuple oposting,
 /*
  * prototypes for functions in nbtinsert.c
  */
-extern bool _bt_doinsert(Relation rel, IndexTuple itup,
-						 IndexUniqueCheck checkUnique, bool indexUnchanged,
-						 Relation heapRel);
 extern void _bt_finish_split(Relation rel, Relation heaprel, Buffer lbuf,
 							 BTStack stack);
 extern Buffer _bt_getstackbuf(Relation rel, Relation heaprel, BTStack stack,
@@ -1227,13 +1219,6 @@ extern void _bt_pendingfsm_finalize(Relation rel, BTVacState *vstate);
 /*
  * prototypes for functions in nbtsearch.c
  */
-extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
-						  Buffer *bufP, int access);
-extern Buffer _bt_moveright(Relation rel, Relation heaprel, BTScanInsert key,
-							Buffer buf, bool forupdate, BTStack stack,
-							int access);
-extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
-extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
 extern bool _bt_first(IndexScanDesc scan, ScanDirection dir);
 extern bool _bt_next(IndexScanDesc scan, ScanDirection dir);
 extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost);
@@ -1241,7 +1226,6 @@ extern Buffer _bt_get_endpoint(Relation rel, uint32 level, bool rightmost);
 /*
  * prototypes for functions in nbtutils.c
  */
-extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
 extern void _bt_freestack(BTStack stack);
 extern void _bt_preprocess_array_keys(IndexScanDesc scan);
 extern void _bt_start_array_keys(IndexScanDesc scan, ScanDirection dir);
@@ -1249,9 +1233,6 @@ extern bool _bt_advance_array_keys(IndexScanDesc scan, ScanDirection dir);
 extern void _bt_mark_array_keys(IndexScanDesc scan);
 extern void _bt_restore_array_keys(IndexScanDesc scan);
 extern void _bt_preprocess_keys(IndexScanDesc scan);
-extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple,
-						  int tupnatts, ScanDirection dir, bool *continuescan,
-						  bool requiredMatchedByPrecheck, bool haveFirstMatch);
 extern void _bt_killitems(IndexScanDesc scan);
 extern BTCycleId _bt_vacuum_cycleid(Relation rel);
 extern BTCycleId _bt_start_vacuum(Relation rel);
@@ -1264,10 +1245,6 @@ extern bool btproperty(Oid index_oid, int attno,
 					   IndexAMProperty prop, const char *propname,
 					   bool *res, bool *isnull);
 extern char *btbuildphasename(int64 phasenum);
-extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
-							   IndexTuple firstright, BTScanInsert itup_key);
-extern int	_bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
-								IndexTuple firstright);
 extern bool _bt_check_natts(Relation rel, bool heapkeyspace, Page page,
 							OffsetNumber offnum);
 extern void _bt_check_third_page(Relation rel, Relation heap,
diff --git a/src/include/access/nbtree_specfuncs.h b/src/include/access/nbtree_specfuncs.h
new file mode 100644
index 0000000000..d2ca62cb3b
--- /dev/null
+++ b/src/include/access/nbtree_specfuncs.h
@@ -0,0 +1,43 @@
+/*
+ * prototypes for functions in nbtree_spec.h
+ */
+extern void _bt_specialize(Relation rel);
+
+extern bool btinsert(Relation rel, Datum *values, bool *isnull,
+					 ItemPointer ht_ctid, Relation heapRel,
+					 IndexUniqueCheck checkUnique, bool indexUnchanged,
+					 struct IndexInfo *indexInfo);
+
+/*
+ * prototypes for functions in nbtdedup_spec.h
+ */
+extern void _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem,
+						   Size newitemsz, bool bottomupdedup);
+
+/*
+ * prototypes for functions in nbtinsert_spec.h
+ */
+
+extern bool _bt_doinsert(Relation rel, IndexTuple itup,
+						 IndexUniqueCheck checkUnique, bool indexUnchanged,
+						 Relation heapRel);
+
+/*
+ * prototypes for functions in nbtsearch_spec.h
+ */
+extern BTStack _bt_search(Relation rel, Relation heaprel, BTScanInsert key,
+						  Buffer *bufP, int access);
+extern OffsetNumber _bt_binsrch_insert(Relation rel, BTInsertState insertstate);
+extern int32 _bt_compare(Relation rel, BTScanInsert key, Page page, OffsetNumber offnum);
+
+/*
+ * prototypes for functions in nbtutils_spec.h
+ */
+extern BTScanInsert _bt_mkscankey(Relation rel, IndexTuple itup);
+extern bool _bt_checkkeys(IndexScanDesc scan, IndexTuple tuple, int tupnatts,
+						  ScanDirection dir, bool *continuescan,
+						  bool requiredMatchedByPrecheck, bool haveFirstMatch);
+extern IndexTuple _bt_truncate(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright, BTScanInsert itup_key);
+extern int _bt_keep_natts_fast(Relation rel, IndexTuple lastleft,
+							   IndexTuple firstright);
diff --git a/src/tools/pginclude/cpluspluscheck b/src/tools/pginclude/cpluspluscheck
index a46ff52cc1..bb9b6640cf 100755
--- a/src/tools/pginclude/cpluspluscheck
+++ b/src/tools/pginclude/cpluspluscheck
@@ -115,6 +115,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
diff --git a/src/tools/pginclude/headerscheck b/src/tools/pginclude/headerscheck
index 0e2d7f537e..567bb9c827 100755
--- a/src/tools/pginclude/headerscheck
+++ b/src/tools/pginclude/headerscheck
@@ -110,6 +110,8 @@ do
 	test "$f" = src/pl/tcl/pltclerrcodes.h && continue
 
 	# Also not meant to be included standalone.
+	test "$f" = src/include/access/nbtree_spec.h && continue
+	test "$f" = src/include/access/nbtree_specfuncs.h && continue
 	test "$f" = src/include/common/unicode_nonspacing_table.h && continue
 	test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
 
-- 
2.40.1

From ea2470d0a416b29fbbcfec9553b4f71c5cb47cd4 Mon Sep 17 00:00:00 2001
From: Matthias van de Meent <boekewurm+postgres@gmail.com>
Date: Wed, 31 Jan 2024 02:21:00 +0100
Subject: [PATCH v16 6/6] btree: Specialize various performance-sensitive
 functions on btree key shape.

nbtree keys are not all made the same, and a significant amount of time is
spent in code that exists only to deal with various key shapes. By specializing
function calls based on the key shape, we can remove or reduce these causes
of overhead.

This commit adds the basic infrastructure for specializing specific hot code
in the nbtree AM to certain shapes of keys, and splits the code that can
benefit from attribute offset optimizations into separate files. This does
NOT yet update the code itself - it just makes the code compile cleanly.
The performance should be comparable if not the same.
---
 src/include/access/itup_attiter.h | 199 ++++++++++++++++++++++++++++++
 src/include/access/nbtree.h       |  20 ++-
 src/include/access/nbtree_spec.h  |  36 ++++++
 3 files changed, 252 insertions(+), 3 deletions(-)
 create mode 100644 src/include/access/itup_attiter.h

diff --git a/src/include/access/itup_attiter.h b/src/include/access/itup_attiter.h
new file mode 100644
index 0000000000..abf52761e7
--- /dev/null
+++ b/src/include/access/itup_attiter.h
@@ -0,0 +1,199 @@
+/*-------------------------------------------------------------------------
+ *
+ * itup_attiter.h
+ *	  POSTGRES index tuple attribute iterator definitions.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/access/itup_attiter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ITUP_ATTITER_H
+#define ITUP_ATTITER_H
+
+#include "access/itup.h"
+#include "varatt.h"
+
+typedef struct IAttrIterStateData
+{
+	int			offset;
+	bool		slow;
+	bool		isNull;
+} IAttrIterStateData;
+
+typedef IAttrIterStateData * IAttrIterState;
+
+/* ----------------
+ *		index_attiterinit
+ *
+ *		This gets called many times, so we macro the cacheable and NULL
+ *		lookups, and call nocache_index_attiterinit() for the rest.
+ *
+ *		tup - the tuple being iterated on
+ *		attnum - the attribute number that we start the iteration with
+ *				 in the first index_attiternext call
+ *		tupdesc - the tuple description
+ *
+ * ----------------
+ */
+#define index_attiterinit(tup, attnum, tupleDesc, iter) \
+do { \
+	if ((attnum) == 1) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			0 /* Offset of attribute 1 is always 0 */, \
+			false /* slow */, \
+			false /* isNull */ \
+		}); \
+	} \
+	else if (!IndexTupleHasNulls(tup) && \
+			 TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff >= 0) \
+	{ \
+		*(iter) = ((IAttrIterStateData) { \
+			TupleDescAttr((tupleDesc), (attnum)-1)->attcacheoff, /* offset */ \
+			false, /* slow */ \
+			false /* isNull */ \
+		}); \
+	} \
+	else \
+		nocache_index_attiterinit((tup), (attnum) - 1, (tupleDesc), (iter)); \
+} while (false);
+
+/*
+ * Initiate an index attribute iterator to attribute attnum,
+ * and return the corresponding datum.
+ *
+ * This is nearly the same as index_deform_tuple, except that this
+ * returns the internal state up to attnum, instead of populating the
+ * datum- and isnull-arrays
+ */
+static inline void
+nocache_index_attiterinit(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	int			curatt;
+	char	   *tp;				/* ptr to tuple data */
+	int			off;			/* offset in tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	bool		slow = false;	/* can we use/set attcacheoff? */
+	bool		null = false;
+
+	/* Assert to protect callers */
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	/* XXX "knows" t_bits are just after fixed tuple header! */
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+	off = 0;
+
+	for (curatt = 0; curatt < attnum; curatt++)
+	{
+		Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, curatt);
+
+		if (hasnulls && att_isnull(curatt, bp))
+		{
+			null = true;
+			slow = true;		/* can't use attcacheoff anymore */
+			continue;
+		}
+
+		null = false;
+
+		if (!slow && thisatt->attcacheoff >= 0)
+			off = thisatt->attcacheoff;
+		else if (thisatt->attlen == -1)
+		{
+			off = att_align_pointer(off, thisatt->attalign, -1,
+									tp + off);
+			slow = true;
+		}
+		else
+		{
+			/* not varlena, so safe to use att_align_nominal */
+			off = att_align_nominal(off, thisatt->attalign);
+		}
+
+		off = att_addlength_pointer(off, thisatt->attlen, tp + off);
+
+		if (thisatt->attlen <= 0)
+			slow = true;		/* can't use attcacheoff anymore */
+	}
+
+	iter->isNull = null;
+	iter->offset = off;
+	iter->slow = slow;
+}
+
+/* ----------------
+ *		index_attiternext() - get the next attribute of an index tuple
+ *
+ *		This gets called many times, so we do the least amount of work
+ *		possible.
+ *
+ *		The code does not attempt to update attcacheoff; as it is unlikely
+ *		to reach a situation where the cached offset matters a lot.
+ *		If the cached offset do matter, the caller should make sure that
+ *		PopulateTupleDescCacheOffsets() was called on the tuple descriptor
+ *		to populate the attribute offset cache.
+ *
+ * ----------------
+ */
+static inline Datum
+index_attiternext(IndexTuple tup, AttrNumber attnum, TupleDesc tupleDesc, IAttrIterState iter)
+{
+	bool		hasnulls = IndexTupleHasNulls(tup);
+	char	   *tp;				/* ptr to tuple data */
+	bits8	   *bp;				/* ptr to null bitmap in tuple */
+	Datum		datum;
+	Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum - 1);
+
+	Assert(PointerIsValid(iter));
+	Assert(tupleDesc->natts <= INDEX_MAX_KEYS);
+	Assert(attnum <= tupleDesc->natts);
+	Assert(attnum > 0);
+
+	bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
+
+	tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
+
+	if (hasnulls && att_isnull(attnum - 1, bp))
+	{
+		iter->isNull = true;
+		iter->slow = true;
+		return (Datum) 0;
+	}
+
+	iter->isNull = false;
+
+	if (!iter->slow && thisatt->attcacheoff >= 0)
+		iter->offset = thisatt->attcacheoff;
+	else if (thisatt->attlen == -1)
+	{
+		iter->offset = att_align_pointer(iter->offset, thisatt->attalign, -1,
+										 tp + iter->offset);
+		iter->slow = true;
+	}
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		iter->offset = att_align_nominal(iter->offset, thisatt->attalign);
+	}
+
+	datum = fetchatt(thisatt, tp + iter->offset);
+
+	iter->offset = att_addlength_pointer(iter->offset, thisatt->attlen, tp + iter->offset);
+
+	if (thisatt->attlen <= 0)
+		iter->slow = true;		/* can't use attcacheoff anymore */
+
+	return datum;
+}
+
+#endif /* ITUP_ATTITER_H */
diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
index 9579fed492..58d8a0fdc3 100644
--- a/src/include/access/nbtree.h
+++ b/src/include/access/nbtree.h
@@ -16,6 +16,7 @@
 
 #include "access/amapi.h"
 #include "access/itup.h"
+#include "access/itup_attiter.h"
 #include "access/sdir.h"
 #include "access/tableam.h"
 #include "access/xlogreader.h"
@@ -1120,6 +1121,7 @@ typedef struct BTOptions
 
 #define NBTS_TYPE_CACHED CACHED
 #define NBTS_TYPE_SINGLE_KEYATT SINGLE_KEYATT
+#define NBTS_TYPE_UNCACHED UNCACHED
 
 /* Generate the specialized function headers */
 #define NBT_FILE "access/nbtree_specfuncs.h"
@@ -1132,15 +1134,23 @@ typedef struct BTOptions
 typedef enum NBTS_CTX {
 	NBTS_CTX_CACHED = 1, /* Equivalent to unspecialized code */
 	NBTS_CTX_SINGLE_KEYATT, /* Single key column index; cannot handle more */
+	NBTS_CTX_UNCACHED, /* Last key attribute can't use attcachoff */
 } NBTS_CTX;
 
 static inline NBTS_CTX _nbt_spec_context(Relation irel)
 {
+	AttrNumber	nKeyAtts;
+
 	Assert(PointerIsValid(irel));
 
-	if (IndexRelationGetNumberOfKeyAttributes(irel) == 1)
+	nKeyAtts = IndexRelationGetNumberOfKeyAttributes(irel);
+
+	if (nKeyAtts == 1)
 		return NBTS_CTX_SINGLE_KEYATT;
 
+	if (TupleDescAttr(irel->rd_att, nKeyAtts - 1)->attcacheoff < -1)
+		return NBTS_CTX_UNCACHED;
+
 	return NBTS_CTX_CACHED;
 }
 
@@ -1183,8 +1193,12 @@ static inline Datum _bt_getfirstatt(IndexTuple tuple, TupleDesc tupleDesc,
 	(NBTS_CTX_NAME == NBTS_CTX_SINGLE_KEYATT) ? ( \
 		NBTS_MAKE_NAME(name, NBTS_TYPE_SINGLE_KEYATT) \
 	) : ( \
-		AssertMacro((NBTS_CTX_NAME) == NBTS_CTX_CACHED), \
-		NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+		((NBTS_CTX_NAME) == NBTS_CTX_UNCACHED) ? ( \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_UNCACHED) \
+		) : ( \
+			AssertMacro((NBTS_CTX_NAME) == NBTS_CTX_CACHED), \
+			NBTS_MAKE_NAME(name, NBTS_TYPE_CACHED) \
+		) \
 	) \
 )
 
diff --git a/src/include/access/nbtree_spec.h b/src/include/access/nbtree_spec.h
index 4919f95e79..2f3f615ea4 100644
--- a/src/include/access/nbtree_spec.h
+++ b/src/include/access/nbtree_spec.h
@@ -153,6 +153,42 @@
 #undef nbts_attiter_nextattdatum
 #undef nbts_attiter_curattisnull
 
+/*
+ * Specialization 3: UNCACHED
+ *
+ * Multiple key columns, but attcacheoff -optimization doesn't apply because
+ * some intermediate or prefixing key attributes that don't have a fixed size
+ * at the type level (i.e. their attlen < 0).
+ */
+#define NBTS_TYPE NBTS_TYPE_UNCACHED
+
+#define nbts_attiterdeclare(itup) \
+	IAttrIterStateData	NBTS_MAKE_NAME(itup, iter)
+
+#define nbts_attiterinit(itup, initAttNum, tupDesc) \
+	index_attiterinit((itup), (initAttNum), (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_foreachattr(initAttNum, endAttNum) \
+	for (int spec_i = (initAttNum); spec_i <= (endAttNum); spec_i++)
+
+#define nbts_attiter_attnum spec_i
+
+#define nbts_attiter_nextattdatum(itup, tupDesc) \
+	index_attiternext((itup), spec_i, (tupDesc), &(NBTS_MAKE_NAME(itup, iter)))
+
+#define nbts_attiter_curattisnull(itup) \
+	NBTS_MAKE_NAME(itup, iter).isNull
+
+#include NBT_SPECIALIZE_FILE
+
+#undef NBTS_TYPE
+#undef nbts_attiterdeclare
+#undef nbts_attiterinit
+#undef nbts_foreachattr
+#undef nbts_attiter_attnum
+#undef nbts_attiter_nextattdatum
+#undef nbts_attiter_curattisnull
+
 /*
  * We're done with templating, so restore or create the macros which can be
  * used in non-template sources.
-- 
2.40.1