agora inbox for [email protected]  

help / color / mirror / Atom feed

[PATCH] fix "Preserve relfilenodes" for pg_largeobject and its index
226+ messages / 3 participants
[nested] [flat]

* [PATCH] fix "Preserve relfilenodes" for pg_largeobject and its index
@ 2022-07-02 05:48  Justin Pryzby <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Justin Pryzby @ 2022-07-02 05:48 UTC (permalink / raw)

An empty table is created by initdb, and the filenode was still pointing to
that, so pg_largeobject was empty after binary upgrades.

Test like:
| ./tmp_install/usr/local/pgsql/bin/initdb --no-sync -D pg15b1.dat -k
| ./tmp_install/usr/local/pgsql/bin/postgres -D pg15b1.dat -c logging_collector=no -p 5678 -k /tmp&
| psql -h /tmp postgres -p 5678 -c '\lo_import /etc/shells' -c 'VACUUM FULL pg_largeobject'
| rm -fr pg15b2.dat && ./tmp_install/usr/local/pgsql/bin/initdb --no-sync -k -D pg15b2.dat && ./tmp_install/usr/local/pgsql/bin/pg_upgrade -d pg15b1.dat -D pg15b2.dat -b ./tmp_install/usr/local/pgsql/bin
| ./tmp_install/usr/local/pgsql/bin/postgres -D pg15b2.dat -c logging_collector=no -p 5678 -k /tmp&

See also:
9a974cbcba005256a19991203583a94b4f9a21a9
https://www.postgresql.org/message-id/20210601140949.GC22012%40momjian.us
https://www.postgresql.org/message-id/20220701231413.GI13040%40telsasoft.com
---
 src/bin/pg_dump/pg_dump.c              | 37 ++++++++------
 src/bin/pg_upgrade/relfilenumber.c     | 68 +++++++++++++++++++++++---
 src/bin/pg_upgrade/t/002_pg_upgrade.pl |  2 +
 3 files changed, 86 insertions(+), 21 deletions(-)

diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c
index 227cdca2e2d..06d436f2f34 100644
--- a/src/bin/pg_dump/pg_dump.c
+++ b/src/bin/pg_dump/pg_dump.c
@@ -3135,7 +3135,7 @@ dumpDatabase(Archive *fout)
 
 	/*
 	 * pg_largeobject comes from the old system intact, so set its
-	 * relfrozenxids and relminmxids.
+	 * relfrozenxids, relminmxids and relfilenode.
 	 */
 	if (dopt->binary_upgrade)
 	{
@@ -3143,34 +3143,41 @@ dumpDatabase(Archive *fout)
 		PQExpBuffer loFrozenQry = createPQExpBuffer();
 		PQExpBuffer loOutQry = createPQExpBuffer();
 		int			i_relfrozenxid,
+					i_relfilenode,
+					i_oid,
 					i_relminmxid;
 
 		/*
 		 * pg_largeobject
 		 */
 		if (fout->remoteVersion >= 90300)
-			appendPQExpBuffer(loFrozenQry, "SELECT relfrozenxid, relminmxid\n"
+			appendPQExpBuffer(loFrozenQry, "SELECT relfrozenxid, relminmxid, relfilenode, oid\n"
 							  "FROM pg_catalog.pg_class\n"
-							  "WHERE oid = %u;\n",
-							  LargeObjectRelationId);
+							  "WHERE oid IN (%u, %u);\n",
+							  LargeObjectRelationId, LargeObjectLOidPNIndexId);
 		else
-			appendPQExpBuffer(loFrozenQry, "SELECT relfrozenxid, 0 AS relminmxid\n"
+			appendPQExpBuffer(loFrozenQry, "SELECT relfrozenxid, 0 AS relminmxid, relfilenode, oid\n"
 							  "FROM pg_catalog.pg_class\n"
-							  "WHERE oid = %u;\n",
-							  LargeObjectRelationId);
+							  "WHERE oid IN (%u, %u);\n",
+							  LargeObjectRelationId, LargeObjectLOidPNIndexId);
 
-		lo_res = ExecuteSqlQueryForSingleRow(fout, loFrozenQry->data);
+		lo_res = ExecuteSqlQuery(fout, loFrozenQry->data, PGRES_TUPLES_OK);
 
 		i_relfrozenxid = PQfnumber(lo_res, "relfrozenxid");
 		i_relminmxid = PQfnumber(lo_res, "relminmxid");
+		i_relfilenode = PQfnumber(lo_res, "relfilenode");
+		i_oid = PQfnumber(lo_res, "oid");
+
+		appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, preserve values for pg_largeobject and its index\n");
+		for (int i = 0; i < PQntuples(lo_res); ++i)
+			appendPQExpBuffer(loOutQry, "UPDATE pg_catalog.pg_class\n"
+							  "SET relfrozenxid = '%u', relminmxid = '%u', relfilenode = '%u'\n"
+							  "WHERE oid = %u;\n",
+							  atooid(PQgetvalue(lo_res, i, i_relfrozenxid)),
+							  atooid(PQgetvalue(lo_res, i, i_relminmxid)),
+							  atooid(PQgetvalue(lo_res, i, i_relfilenode)),
+							  atooid(PQgetvalue(lo_res, i, i_oid)));
 
-		appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, set pg_largeobject relfrozenxid and relminmxid\n");
-		appendPQExpBuffer(loOutQry, "UPDATE pg_catalog.pg_class\n"
-						  "SET relfrozenxid = '%u', relminmxid = '%u'\n"
-						  "WHERE oid = %u;\n",
-						  atooid(PQgetvalue(lo_res, 0, i_relfrozenxid)),
-						  atooid(PQgetvalue(lo_res, 0, i_relminmxid)),
-						  LargeObjectRelationId);
 		ArchiveEntry(fout, nilCatalogId, createDumpId(),
 					 ARCHIVE_OPTS(.tag = "pg_largeobject",
 								  .description = "pg_largeobject",
diff --git a/src/bin/pg_upgrade/relfilenumber.c b/src/bin/pg_upgrade/relfilenumber.c
index b3ad8209eca..0dd649aa0f5 100644
--- a/src/bin/pg_upgrade/relfilenumber.c
+++ b/src/bin/pg_upgrade/relfilenumber.c
@@ -13,9 +13,13 @@
 
 #include "access/transam.h"
 #include "catalog/pg_class_d.h"
+#include "catalog/pg_largeobject_d.h"
 #include "pg_upgrade.h"
 
-static void transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace);
+static void transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace,
+	bool *has_lotable, bool *has_loindex);
+static void remove_stray_largeobject_files(DbInfo *new_db, bool has_lotable,
+		bool has_loindex);
 static void transfer_relfile(FileNameMap *map, const char *suffix, bool vm_must_add_frozenbit);
 
 
@@ -98,6 +102,8 @@ transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr,
 				   *new_db = NULL;
 		FileNameMap *mappings;
 		int			n_maps;
+		bool		has_lotable = false;
+		bool		has_loindex = false;
 
 		/*
 		 * Advance past any databases that exist in the new cluster but not in
@@ -117,22 +123,66 @@ transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr,
 
 		mappings = gen_db_file_maps(old_db, new_db, &n_maps, old_pgdata,
 									new_pgdata);
-		if (n_maps)
-		{
-			transfer_single_new_db(mappings, n_maps, old_tablespace);
-		}
+		transfer_single_new_db(mappings, n_maps, old_tablespace,
+			&has_lotable, &has_loindex);
+
+		/*
+		 * Remove the original pg_largeobject files created by initdb if they
+		 * exist in the new cluster with different relfilenodes.  This avoids
+		 * leaving behind stray files unassociated with any relation.
+		 */
+		remove_stray_largeobject_files(new_db, has_lotable, has_loindex);
+
 		/* We allocate something even for n_maps == 0 */
 		pg_free(mappings);
 	}
 }
 
+/*
+ * If there's no relation in the cluster whose relfilenode is the OID of the
+ * largeobject table/index, then remove the stray file.  It ought to have a
+ * single segment and fork.
+ */
+static void
+remove_stray_largeobject_files(DbInfo *new_db, bool has_lotable,
+		bool has_loindex)
+{
+	char		prefix[MAXPGPATH];
+	char		largeobj_file[MAXPGPATH];
+
+	if (new_db->db_tablespace[0] != '\0')
+		snprintf(prefix, sizeof(prefix), "%s/%s/%u",
+				new_db->db_tablespace, new_cluster.tablespace_suffix,
+				new_db->db_oid);
+	else
+		snprintf(prefix, sizeof(prefix), "%s/base/%u",
+				new_cluster.pgdata, new_db->db_oid);
+
+	if (!has_lotable)
+	{
+		snprintf(largeobj_file, sizeof(largeobj_file), "%s/%u",
+				prefix, LargeObjectRelationId);
+		if (unlink(largeobj_file) != 0)
+			pg_fatal("Unable to remove %s.\n", largeobj_file);
+	}
+
+	if (!has_loindex)
+	{
+		snprintf(largeobj_file, sizeof(largeobj_file), "%s/%u",
+				prefix, LargeObjectLOidPNIndexId);
+		if (unlink(largeobj_file) != 0)
+			pg_fatal("Unable to remove %s.\n", largeobj_file);
+	}
+}
+
 /*
  * transfer_single_new_db()
  *
  * create links for mappings stored in "maps" array.
  */
 static void
-transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
+transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace,
+	bool *has_lotable, bool *has_loindex)
 {
 	int			mapnum;
 	bool		vm_must_add_frozenbit = false;
@@ -146,6 +196,12 @@ transfer_single_new_db(FileNameMap *maps, int size, char *old_tablespace)
 
 	for (mapnum = 0; mapnum < size; mapnum++)
 	{
+		/* Keep track of whether a filenode matches the OID */
+		if (maps[mapnum].relfilenumber == LargeObjectRelationId)
+			*has_lotable = true;
+		if (maps[mapnum].relfilenumber == LargeObjectLOidPNIndexId)
+			*has_loindex = true;
+
 		if (old_tablespace == NULL ||
 			strcmp(maps[mapnum].old_tablespace, old_tablespace) == 0)
 		{
diff --git a/src/bin/pg_upgrade/t/002_pg_upgrade.pl b/src/bin/pg_upgrade/t/002_pg_upgrade.pl
index 2f9b13bf0ae..9ed48c4e06a 100644
--- a/src/bin/pg_upgrade/t/002_pg_upgrade.pl
+++ b/src/bin/pg_upgrade/t/002_pg_upgrade.pl
@@ -208,6 +208,8 @@ if (defined($ENV{oldinstall}))
 	}
 }
 
+$oldnode->safe_psql("regression", "VACUUM FULL pg_largeobject;");
+
 # In a VPATH build, we'll be started in the source directory, but we want
 # to run pg_upgrade in the build directory so that any files generated finish
 # in it, like delete_old_cluster.{sh,bat}.
-- 
2.17.1


--m+utxuhC6KVTvgNz--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH v8 2/2] handle relation statistics correctly during rewrites
@ 2025-11-04 13:52  Bertrand Drouvot <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Bertrand Drouvot @ 2025-11-04 13:52 UTC (permalink / raw)

Now that PGSTAT_KIND_RELATION is keyed by refilenode, we need to handle rewrites.

To do so, this patch:

- Adds PgStat_PendingRewrite, a new struct to track rewrite operations within
a transaction, storing the old locator, new locator, and original locator (for
rewrite chains). This allows stats to be copied from the original location to
the final location at commit time.

- Adds a new function, pgstat_mark_rewrite(), called when a table rewrite begins.
It records the rewrite operation in a local list and detects rewrite chains by
checking if the old_locator matches any existing new_locator, preserving the
chain's original_locator.

- Modifies pgstat_copy_relation_stats(), to accept RelFileLocators instead of
Relations, with a new increment parameter to accumulate stats (needed for rewrite
chains with DML between rewrites).

- Ensures that AtEOXact_PgStat_Relations(), AtPrepare_PgStat_Relations(),
pgstat_twophase_postcommit()/postabort() pgstat_drop_relation() handle the
PgStat_PendingRewrite list correctly.

Note that due to the new flush call in pgstat_twophase_postcommit() we can not
call GetCurrentTransactionStopTimestamp() in pgstat_relation_flush_cb(). So,
adding a check to handle this special case and call GetCurrentTimestamp() instead.
Note that we'd call GetCurrentTimestamp() only if there is a rewrite, so that
the GetCurrentTimestamp() extra cost should be negligible. Another solution
could be to trigger the flush from FinishPreparedTransaction() but that's not
worth the extra complexity.

The new pending_rewrites list is traversed in multiple places. The overhead
should be negligible in comparison to a rewrite and the list should not contain
a lot of rewrites in practice.

The pending_rewrites list is traversed in multiple places. In typical usage,
the list will contain only a few entries so the traversal cost is negligible (
furthermore in comparison to a rewrite).
---
 src/backend/catalog/index.c                  |   2 +-
 src/backend/commands/cluster.c               |   5 +
 src/backend/commands/tablecmds.c             |   6 +
 src/backend/utils/activity/pgstat_relation.c | 391 ++++++++++++++++++-
 src/backend/utils/activity/pgstat_xact.c     |  25 +-
 src/backend/utils/cache/relcache.c           |   6 +
 src/include/pgstat.h                         |   5 +-
 src/tools/pgindent/typedefs.list             |   1 +
 8 files changed, 424 insertions(+), 17 deletions(-)
  92.8% src/backend/utils/activity/
   4.9% src/backend/

diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 8dea58ad96b..b71925a22c3 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -1795,7 +1795,7 @@ index_concurrently_swap(Oid newIndexId, Oid oldIndexId, const char *oldName)
 	changeDependenciesOn(RelationRelationId, oldIndexId, newIndexId);
 
 	/* copy over statistics from old to new index */
-	pgstat_copy_relation_stats(newClassRel, oldClassRel);
+	pgstat_copy_relation_stats(newClassRel->rd_locator, oldClassRel->rd_locator, false);
 
 	/* Copy data of pg_statistic from the old index to the new one */
 	CopyStatistics(oldIndexId, newIndexId);
diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index 2120c85ccb4..6155b12afab 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -1196,6 +1196,11 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 
 		rel1 = relation_open(r1, NoLock);
 		rel2 = relation_open(r2, NoLock);
+
+		/* Mark that a rewrite happened */
+		if (RELKIND_HAS_STORAGE(rel1->rd_rel->relkind))
+			pgstat_mark_rewrite(rel1->rd_locator, rel2->rd_locator);
+
 		rel2->rd_createSubid = rel1->rd_createSubid;
 		rel2->rd_newRelfilelocatorSubid = rel1->rd_newRelfilelocatorSubid;
 		rel2->rd_firstRelfilelocatorSubid = rel1->rd_firstRelfilelocatorSubid;
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 6b1a00ed477..9de70f321ed 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -16884,6 +16884,7 @@ ATExecSetTableSpace(Oid tableOid, Oid newTableSpace, LOCKMODE lockmode)
 	Oid			reltoastrelid;
 	RelFileNumber newrelfilenumber;
 	RelFileLocator newrlocator;
+	RelFileLocator oldrlocator;
 	List	   *reltoastidxids = NIL;
 	ListCell   *lc;
 
@@ -16922,6 +16923,7 @@ ATExecSetTableSpace(Oid tableOid, Oid newTableSpace, LOCKMODE lockmode)
 	newrlocator = rel->rd_locator;
 	newrlocator.relNumber = newrelfilenumber;
 	newrlocator.spcOid = newTableSpace;
+	oldrlocator = rel->rd_locator;
 
 	/* hand off to AM to actually create new rel storage and copy the data */
 	if (rel->rd_rel->relkind == RELKIND_INDEX)
@@ -16934,6 +16936,10 @@ ATExecSetTableSpace(Oid tableOid, Oid newTableSpace, LOCKMODE lockmode)
 		table_relation_copy_data(rel, &newrlocator);
 	}
 
+	/* mark that a rewrite happened */
+	if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
+		pgstat_mark_rewrite(oldrlocator, newrlocator);
+
 	/*
 	 * Update the pg_class row.
 	 *
diff --git a/src/backend/utils/activity/pgstat_relation.c b/src/backend/utils/activity/pgstat_relation.c
index ee6f2eb2bdb..83103189fb5 100644
--- a/src/backend/utils/activity/pgstat_relation.c
+++ b/src/backend/utils/activity/pgstat_relation.c
@@ -30,6 +30,19 @@
 #include "utils/syscache.h"
 #include "utils/timestamp.h"
 
+/* Pending rewrite operations for stats copying */
+typedef struct PgStat_PendingRewrite
+{
+	RelFileLocator old_locator;
+	RelFileLocator new_locator;
+	RelFileLocator original_locator;
+	int			nest_level;		/* Transaction nesting level where rewrite
+								 * occurred */
+	struct PgStat_PendingRewrite *next;
+} PgStat_PendingRewrite;
+
+/* The pending rewrites list for current transaction */
+static PgStat_PendingRewrite *pending_rewrites = NULL;
 
 /* Record that's written to 2PC state file when pgstat state is persisted */
 typedef struct TwoPhasePgStatRecord
@@ -43,6 +56,8 @@ typedef struct TwoPhasePgStatRecord
 	PgStat_Counter deleted_pre_truncdrop;
 	RelFileLocator locator;		/* table's rd_locator */
 	bool		truncdropped;	/* was the relation truncated/dropped? */
+	RelFileLocator rewrite_old_locator;
+	int			rewrite_nest_level;
 } TwoPhasePgStatRecord;
 
 
@@ -54,27 +69,70 @@ static void restore_truncdrop_counters(PgStat_TableXactStatus *trans);
 
 
 /*
- * Copy stats between relations. This is used for things like REINDEX
+ * Copy stats between RelFileLocator. This is used for things like REINDEX
  * CONCURRENTLY.
  */
 void
-pgstat_copy_relation_stats(Relation dst, Relation src)
+pgstat_copy_relation_stats(RelFileLocator dst, RelFileLocator src, bool increment)
 {
 	PgStat_StatTabEntry *srcstats;
 	PgStatShared_Relation *dstshstats;
 	PgStat_EntryRef *dst_ref;
 
-	srcstats = pgstat_fetch_stat_tabentry_ext(RelationGetRelid(src));
+	srcstats = (PgStat_StatTabEntry *) pgstat_fetch_entry(PGSTAT_KIND_RELATION,
+														  src.dbOid,
+														  RelFileLocatorToPgStatObjid(src));
 	if (!srcstats)
 		return;
 
 	dst_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION,
-										  dst->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
-										  RelationGetRelid(dst),
+										  dst.dbOid,
+										  RelFileLocatorToPgStatObjid(dst),
 										  false);
 
 	dstshstats = (PgStatShared_Relation *) dst_ref->shared_stats;
-	dstshstats->stats = *srcstats;
+
+	if (!increment)
+		dstshstats->stats = *srcstats;
+	else
+	{
+		/* Increment those statistics */
+#define RELFSTAT_ACC(fld, stats_to_add) \
+	(dstshstats->stats.fld += stats_to_add->fld)
+		RELFSTAT_ACC(numscans, srcstats);
+		RELFSTAT_ACC(tuples_returned, srcstats);
+		RELFSTAT_ACC(tuples_fetched, srcstats);
+		RELFSTAT_ACC(tuples_inserted, srcstats);
+		RELFSTAT_ACC(tuples_updated, srcstats);
+		RELFSTAT_ACC(tuples_deleted, srcstats);
+		RELFSTAT_ACC(tuples_hot_updated, srcstats);
+		RELFSTAT_ACC(tuples_newpage_updated, srcstats);
+		RELFSTAT_ACC(live_tuples, srcstats);
+		RELFSTAT_ACC(dead_tuples, srcstats);
+		RELFSTAT_ACC(mod_since_analyze, srcstats);
+		RELFSTAT_ACC(ins_since_vacuum, srcstats);
+		RELFSTAT_ACC(blocks_fetched, srcstats);
+		RELFSTAT_ACC(blocks_hit, srcstats);
+		RELFSTAT_ACC(vacuum_count, srcstats);
+		RELFSTAT_ACC(autovacuum_count, srcstats);
+		RELFSTAT_ACC(analyze_count, srcstats);
+		RELFSTAT_ACC(autoanalyze_count, srcstats);
+		RELFSTAT_ACC(total_vacuum_time, srcstats);
+		RELFSTAT_ACC(total_autovacuum_time, srcstats);
+		RELFSTAT_ACC(total_analyze_time, srcstats);
+		RELFSTAT_ACC(total_autoanalyze_time, srcstats);
+#undef RELFSTAT_ACC
+
+		/* Replace those statistics */
+#define RELFSTAT_REP(fld, stats_to_rep) \
+	(dstshstats->stats.fld = stats_to_rep->fld)
+		RELFSTAT_REP(lastscan, srcstats);
+		RELFSTAT_REP(last_vacuum_time, srcstats);
+		RELFSTAT_REP(last_autovacuum_time, srcstats);
+		RELFSTAT_REP(last_analyze_time, srcstats);
+		RELFSTAT_REP(last_autoanalyze_time, srcstats);
+#undef RELFSTAT_REP
+	}
 
 	pgstat_unlock_entry(dst_ref);
 }
@@ -136,6 +194,7 @@ void
 pgstat_assoc_relation(Relation rel)
 {
 	RelFileLocator locator;
+	PgStat_TableStatus *pgstat_info;
 
 	Assert(rel->pgstat_enabled);
 	Assert(rel->pgstat_info == NULL);
@@ -165,14 +224,54 @@ pgstat_assoc_relation(Relation rel)
 		locator.relNumber = rel->rd_id;
 	}
 
+	/*
+	 * If this relation was rewritten during the current transaction we may be
+	 * reopening it with its new RelFileLocator. In that case, continue using
+	 * the stats entry associated with the old locator rather than creating a
+	 * new one. This ensures all stats from before and after the rewrite are
+	 * tracked in a single entry which will be properly copied to the new
+	 * locator at transaction commit.
+	 */
+	if (pending_rewrites != NULL)
+	{
+		PgStat_PendingRewrite *rewrite;
+
+		for (rewrite = pending_rewrites; rewrite != NULL; rewrite = rewrite->next)
+		{
+			if (locator.dbOid == rewrite->new_locator.dbOid &&
+				locator.spcOid == rewrite->new_locator.spcOid &&
+				locator.relNumber == rewrite->new_locator.relNumber)
+			{
+				pgstat_info = pgstat_prep_relation_pending(rewrite->old_locator);
+				goto found_entry;
+			}
+		}
+	}
+
 	/* Else find or make the PgStat_TableStatus entry, and update link */
-	rel->pgstat_info = pgstat_prep_relation_pending(locator);
+	pgstat_info = pgstat_prep_relation_pending(locator);
+
+found_entry:
+	rel->pgstat_info = pgstat_info;
+
+	/*
+	 * For relations stats, we key by physical file location, not by relation
+	 * OID. This means during operations like ALTER TYPE it's possible that
+	 * the relation OID changes but the relfilenode stays the same (no actual
+	 * rewrite needed). Unlink the old relation first.
+	 */
+	if (pgstat_info->relation != NULL &&
+		pgstat_info->relation != rel)
+	{
+		pgstat_info->relation->pgstat_info = NULL;
+		pgstat_info->relation = NULL;
+	}
 
 	/* don't allow link a stats to multiple relcache entries */
-	Assert(rel->pgstat_info->relation == NULL);
+	Assert(pgstat_info->relation == NULL);
 
 	/* mark this relation as the owner */
-	rel->pgstat_info->relation = rel;
+	pgstat_info->relation = rel;
 }
 
 /*
@@ -215,14 +314,37 @@ pgstat_drop_relation(Relation rel)
 {
 	int			nest_level = GetCurrentTransactionNestLevel();
 	PgStat_TableStatus *pgstat_info;
+	bool		skip_transactional_drop = false;
 
 	/* don't track stats for relations without storage */
 	if (!RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
 		return;
 
-	pgstat_drop_transactional(PGSTAT_KIND_RELATION,
-							  rel->rd_locator.dbOid,
-							  RelFileLocatorToPgStatObjid(rel->rd_locator));
+	/* Check if this drop is part of a pending rewrite */
+	if (pending_rewrites != NULL)
+	{
+		PgStat_PendingRewrite *rewrite;
+
+		for (rewrite = pending_rewrites; rewrite != NULL; rewrite = rewrite->next)
+		{
+			if (rel->rd_locator.dbOid == rewrite->old_locator.dbOid &&
+				rel->rd_locator.spcOid == rewrite->old_locator.spcOid &&
+				rel->rd_locator.relNumber == rewrite->old_locator.relNumber)
+			{
+				skip_transactional_drop = true;
+				break;
+			}
+		}
+	}
+
+	/*
+	 * If it is part of a rewrite, drop its stats later, for example in
+	 * AtEOXact_PgStat_Relations(), so skip it here.
+	 */
+	if (!skip_transactional_drop)
+		pgstat_drop_transactional(PGSTAT_KIND_RELATION,
+								  rel->rd_locator.dbOid,
+								  RelFileLocatorToPgStatObjid(rel->rd_locator));
 
 	if (!pgstat_should_count_relation(rel))
 		return;
@@ -660,6 +782,48 @@ AtEOXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit)
 		}
 		tabstat->trans = NULL;
 	}
+
+	/* preserve the stats in case of rewrite */
+	if (isCommit && pending_rewrites != NULL)
+	{
+		PgStat_PendingRewrite *rewrite;
+		PgStat_PendingRewrite *prev = NULL;
+		PgStat_PendingRewrite *current = pending_rewrites;
+		PgStat_PendingRewrite *next;
+
+		/* reverse the rewrites list to process in chronological order */
+		while (current != NULL)
+		{
+			next = current->next;
+			current->next = prev;
+			prev = current;
+			current = next;
+		}
+
+		/* now process rewrites in chronological order */
+		for (rewrite = prev; rewrite != NULL; rewrite = rewrite->next)
+		{
+			PgStat_EntryRef *old_entry_ref;
+
+			old_entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION,
+													   rewrite->old_locator.dbOid,
+													   RelFileLocatorToPgStatObjid(rewrite->old_locator));
+
+			if (old_entry_ref && old_entry_ref->pending)
+				pgstat_relation_flush_cb(old_entry_ref, false);
+
+			pgstat_copy_relation_stats(rewrite->new_locator,
+									   rewrite->old_locator, true);
+
+			/* drop old locator's stats */
+			if (!pgstat_drop_entry(PGSTAT_KIND_RELATION,
+								   rewrite->old_locator.dbOid,
+								   RelFileLocatorToPgStatObjid(rewrite->old_locator)))
+				pgstat_request_entry_refs_gc();
+		}
+	}
+
+	pending_rewrites = NULL;
 }
 
 /*
@@ -675,6 +839,30 @@ AtEOSubXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit, in
 	PgStat_TableXactStatus *trans;
 	PgStat_TableXactStatus *next_trans;
 
+	/*
+	 * If we don't commit then remove the associated rewrites if any, to keep
+	 * the rewrite chain in sync with what will be eventually committed.
+	 */
+	if (!isCommit)
+	{
+		PgStat_PendingRewrite **rewrite_ptr = &pending_rewrites;
+
+		while (*rewrite_ptr != NULL)
+		{
+			if ((*rewrite_ptr)->nest_level >= nestDepth)
+			{
+				PgStat_PendingRewrite *to_remove = *rewrite_ptr;
+
+				*rewrite_ptr = (*rewrite_ptr)->next;
+				pfree(to_remove);
+			}
+			else
+			{
+				rewrite_ptr = &((*rewrite_ptr)->next);
+			}
+		}
+	}
+
 	for (trans = xact_state->first; trans != NULL; trans = next_trans)
 	{
 		PgStat_TableStatus *tabstat;
@@ -754,11 +942,19 @@ void
 AtPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)
 {
 	PgStat_TableXactStatus *trans;
+	PgStat_PendingRewrite *rewrite;
 
+	/*
+	 * For each tabstat, find its matching rewrite and remove it from the
+	 * pending rewrites list. This way, after processing all tabstats, pending
+	 * rewrites will only contain rewrite only transactions.
+	 */
 	for (trans = xact_state->first; trans != NULL; trans = trans->next)
 	{
 		PgStat_TableStatus *tabstat PG_USED_FOR_ASSERTS_ONLY;
 		TwoPhasePgStatRecord record;
+		PgStat_PendingRewrite **rewrite_ptr;
+		bool		found_rewrite = false;
 
 		Assert(trans->nest_level == 1);
 		Assert(trans->upper == NULL);
@@ -778,10 +974,83 @@ AtPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)
 			record.locator = tabstat->locator;
 
 		record.truncdropped = trans->truncdropped;
+		record.rewrite_nest_level = 0;
+
+		/*
+		 * Look for a matching rewrite and remove it from pending rewrites. We
+		 * check three possible matches:
+		 *
+		 * The new_locator when stats have been added after the rewrite. The
+		 * old_locator when stats have been added before the rewrite but not
+		 * after. The original_locator when this tabstat is part of a rewrite
+		 * chain.
+		 */
+		rewrite_ptr = &pending_rewrites;
+		while (*rewrite_ptr != NULL)
+		{
+			rewrite = *rewrite_ptr;
+
+			if ((record.locator.dbOid == rewrite->new_locator.dbOid &&
+				 record.locator.spcOid == rewrite->new_locator.spcOid &&
+				 record.locator.relNumber == rewrite->new_locator.relNumber) ||
+				(tabstat->locator.dbOid == rewrite->old_locator.dbOid &&
+				 tabstat->locator.spcOid == rewrite->old_locator.spcOid &&
+				 tabstat->locator.relNumber == rewrite->old_locator.relNumber) ||
+				(tabstat->locator.dbOid == rewrite->original_locator.dbOid &&
+				 tabstat->locator.spcOid == rewrite->original_locator.spcOid &&
+				 tabstat->locator.relNumber == rewrite->original_locator.relNumber))
+			{
+				/*
+				 * Found matching rewrite. Record the rewrite information and
+				 * remove this rewrite from the list since it's now handled.
+				 */
+				record.rewrite_old_locator = rewrite->original_locator;
+				record.rewrite_nest_level = rewrite->nest_level;
+				record.locator = rewrite->new_locator;
+				found_rewrite = true;
+
+				/* Remove from pending_rewrites list */
+				*rewrite_ptr = rewrite->next;
+				pfree(rewrite);
+				break;
+			}
+			else
+			{
+				/* Move to next rewrite in the list */
+				rewrite_ptr = &(rewrite->next);
+			}
+		}
+
+		/* If no rewrite found, clear the rewrite fields */
+		if (!found_rewrite)
+		{
+			memset(&record.rewrite_old_locator, 0, sizeof(RelFileLocator));
+		}
+
+		RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
+							   &record, sizeof(TwoPhasePgStatRecord));
+	}
+
+	/*
+	 * Now process any rewrites still pending. These are rewrite only
+	 * transactions. We need to preserve their stats even though there's no
+	 * tabstat entry for them.
+	 */
+	for (rewrite = pending_rewrites; rewrite != NULL; rewrite = rewrite->next)
+	{
+		TwoPhasePgStatRecord record;
+
+		memset(&record, 0, sizeof(TwoPhasePgStatRecord));
+		record.locator = rewrite->new_locator;
+		record.rewrite_old_locator = rewrite->original_locator;
+		record.rewrite_nest_level = rewrite->nest_level;
+		record.truncdropped = false;
 
 		RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
 							   &record, sizeof(TwoPhasePgStatRecord));
 	}
+
+	pending_rewrites = NULL;
 }
 
 /*
@@ -804,6 +1073,8 @@ PostPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)
 		tabstat = trans->parent;
 		tabstat->trans = NULL;
 	}
+
+	pending_rewrites = NULL;
 }
 
 /*
@@ -839,6 +1110,29 @@ pgstat_twophase_postcommit(FullTransactionId fxid, uint16 info,
 	pgstat_info->counts.changed_tuples +=
 		rec->tuples_inserted + rec->tuples_updated +
 		rec->tuples_deleted;
+
+	if (rec->rewrite_nest_level > 0)
+	{
+		PgStat_EntryRef *old_entry_ref;
+
+		/* Flush any pending stats for old locator first */
+		old_entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION,
+												   rec->rewrite_old_locator.dbOid,
+												   RelFileLocatorToPgStatObjid(rec->rewrite_old_locator));
+
+		if (old_entry_ref && old_entry_ref->pending)
+			pgstat_relation_flush_cb(old_entry_ref, false);
+
+		/* Copy stats from old to new locator */
+		pgstat_copy_relation_stats(rec->locator, rec->rewrite_old_locator,
+								   true);
+
+		/* Drop old locator's stats */
+		if (!pgstat_drop_entry(PGSTAT_KIND_RELATION,
+							   rec->rewrite_old_locator.dbOid,
+							   RelFileLocatorToPgStatObjid(rec->rewrite_old_locator)))
+			pgstat_request_entry_refs_gc();
+	}
 }
 
 /*
@@ -853,9 +1147,26 @@ pgstat_twophase_postabort(FullTransactionId fxid, uint16 info,
 {
 	TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
 	PgStat_TableStatus *pgstat_info;
+	RelFileLocator target_locator;
+
+	/*
+	 * For aborted transactions with rewrites (like TRUNCATE), we need to
+	 * restore stats to the old locator, not the new one. The new locator
+	 * should be dropped since the rewrite is being rolled back.
+	 */
+	if (rec->rewrite_nest_level > 0)
+	{
+		/* Use the old locator */
+		target_locator = rec->rewrite_old_locator;
+	}
+	else
+	{
+		/* No rewrite, use the original locator */
+		target_locator = rec->locator;
+	}
 
 	/* Find or create a tabstat entry for the target locator */
-	pgstat_info = pgstat_prep_relation_pending(rec->locator);
+	pgstat_info = pgstat_prep_relation_pending(target_locator);
 
 	/* Same math as in AtEOXact_PgStat, abort case */
 	if (rec->truncdropped)
@@ -910,7 +1221,17 @@ pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool nowait)
 	tabentry->numscans += lstats->counts.numscans;
 	if (lstats->counts.numscans)
 	{
-		TimestampTz t = GetCurrentTransactionStopTimestamp();
+		TimestampTz t;
+
+		/*
+		 * Checking the transaction state due to the flush call in
+		 * pgstat_twophase_postcommit() that would break the assertion on the
+		 * state in GetCurrentTransactionStopTimestamp().
+		 */
+		if (!IsTransactionState())
+			t = GetCurrentTransactionStopTimestamp();
+		else
+			t = GetCurrentTimestamp();
 
 		if (t > tabentry->lastscan)
 			tabentry->lastscan = t;
@@ -1162,3 +1483,45 @@ pgstat_reloid_to_relfilelocator(Oid reloid, RelFileLocator *locator)
 	ReleaseSysCache(tuple);
 	return result;
 }
+
+/*
+ * Mark that a relation rewrite has occurred, preserving the original locator
+ * so stats can be copied at transaction commit.
+ */
+void
+pgstat_mark_rewrite(RelFileLocator old_locator, RelFileLocator new_locator)
+{
+	PgStat_PendingRewrite *rewrite;
+	PgStat_PendingRewrite *existing;
+	RelFileLocator original_locator = old_locator;
+
+	for (existing = pending_rewrites; existing != NULL; existing = existing->next)
+	{
+		if (old_locator.dbOid == existing->new_locator.dbOid &&
+			old_locator.spcOid == existing->new_locator.spcOid &&
+			old_locator.relNumber == existing->new_locator.relNumber)
+		{
+			original_locator = existing->original_locator;
+			break;
+		}
+	}
+
+	/* Allocate in TopTransactionContext memory context */
+	rewrite = MemoryContextAlloc(TopTransactionContext,
+								 sizeof(PgStat_PendingRewrite));
+
+	rewrite->old_locator = old_locator;
+	rewrite->new_locator = new_locator;
+	rewrite->original_locator = original_locator;
+	rewrite->nest_level = GetCurrentTransactionNestLevel();
+
+	/* Add to the list */
+	rewrite->next = pending_rewrites;
+	pending_rewrites = rewrite;
+}
+
+void
+pgstat_clear_rewrite(void)
+{
+	pending_rewrites = NULL;
+}
diff --git a/src/backend/utils/activity/pgstat_xact.c b/src/backend/utils/activity/pgstat_xact.c
index bc9864bd8d9..f8cf3755ce2 100644
--- a/src/backend/utils/activity/pgstat_xact.c
+++ b/src/backend/utils/activity/pgstat_xact.c
@@ -55,6 +55,8 @@ AtEOXact_PgStat(bool isCommit, bool parallel)
 	}
 	pgStatXactStack = NULL;
 
+	pgstat_clear_rewrite();
+
 	/* Make sure any stats snapshot is thrown away */
 	pgstat_clear_snapshot();
 }
@@ -360,8 +362,29 @@ create_drop_transactional_internal(PgStat_Kind kind, Oid dboid, uint64 objid, bo
 void
 pgstat_create_transactional(PgStat_Kind kind, Oid dboid, uint64 objid)
 {
-	if (pgstat_get_entry_ref(kind, dboid, objid, false, NULL))
+	PgStat_EntryRef *entry_ref;
+
+	entry_ref = pgstat_get_entry_ref(kind, dboid, objid, false, NULL);
+
+	if (entry_ref)
 	{
+		/*
+		 * For relations stats, we key by physical file location, not by
+		 * relation OID. This means during operations like ALTER TYPE where
+		 * the relation OID changes but the relfilenode stays the same (no
+		 * actual rewrite needed), we'll find an existing entry.
+		 *
+		 * This is expected behavior, we want to preserve stats across the
+		 * catalog change. Simply reset and recreate the entry for the new
+		 * relation OID without warning.
+		 */
+		if (kind == PGSTAT_KIND_RELATION)
+		{
+			pgstat_reset(kind, dboid, objid);
+			create_drop_transactional_internal(kind, dboid, objid, true);
+			return;
+		}
+
 		ereport(WARNING,
 				errmsg("resetting existing statistics for kind %s, db=%u, oid=%" PRIu64,
 					   (pgstat_get_kind_info(kind))->name, dboid,
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 2d0cb7bcfd4..c98e5c51d63 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -85,6 +85,7 @@
 #include "utils/inval.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
+#include "utils/pgstat_internal.h"
 #include "utils/relmapper.h"
 #include "utils/resowner.h"
 #include "utils/snapmgr.h"
@@ -3780,6 +3781,7 @@ RelationSetNewRelfilenumber(Relation relation, char persistence)
 	MultiXactId minmulti = InvalidMultiXactId;
 	TransactionId freezeXid = InvalidTransactionId;
 	RelFileLocator newrlocator;
+	RelFileLocator oldrlocator = relation->rd_locator;
 
 	if (!IsBinaryUpgrade)
 	{
@@ -3951,6 +3953,10 @@ RelationSetNewRelfilenumber(Relation relation, char persistence)
 
 	table_close(pg_class, RowExclusiveLock);
 
+	/* Mark that a rewrite happened */
+	if (RELKIND_HAS_STORAGE(relation->rd_rel->relkind))
+		pgstat_mark_rewrite(oldrlocator, newrlocator);
+
 	/*
 	 * Make the pg_class row change or relation map change visible.  This will
 	 * cause the relcache entry to get updated, too.
diff --git a/src/include/pgstat.h b/src/include/pgstat.h
index c9e451094f3..33d530740d0 100644
--- a/src/include/pgstat.h
+++ b/src/include/pgstat.h
@@ -670,7 +670,7 @@ extern PgStat_FunctionCounts *find_funcstat_entry(Oid func_id);
 
 extern void pgstat_create_relation(Relation rel);
 extern void pgstat_drop_relation(Relation rel);
-extern void pgstat_copy_relation_stats(Relation dst, Relation src);
+extern void pgstat_copy_relation_stats(RelFileLocator dst, RelFileLocator src, bool increment);
 
 extern void pgstat_init_relation(Relation rel);
 extern void pgstat_assoc_relation(Relation rel);
@@ -682,6 +682,9 @@ extern void pgstat_report_vacuum(RelFileLocator locator, PgStat_Counter livetupl
 extern void pgstat_report_analyze(Relation rel,
 								  PgStat_Counter livetuples, PgStat_Counter deadtuples,
 								  bool resetcounter, TimestampTz starttime);
+extern void pgstat_mark_rewrite(RelFileLocator old_locator,
+								RelFileLocator new_locator);
+extern void pgstat_clear_rewrite(void);
 
 /*
  * If stats are enabled, but pending data hasn't been prepared yet, call
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 3451538565e..0ca3eae8026 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2268,6 +2268,7 @@ PgStat_KindInfo
 PgStat_LocalState
 PgStat_PendingDroppedStatsItem
 PgStat_PendingIO
+PgStat_PendingRewrite
 PgStat_SLRUStats
 PgStat_ShmemControl
 PgStat_Snapshot
-- 
2.34.1


--BHD/2LBqtxMXWADJ--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread

* [PATCH 5/5] Serialize decoded tuples without flattening.
@ 2026-02-27 18:01  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 226+ messages in thread

From: Antonin Houska @ 2026-02-27 18:01 UTC (permalink / raw)

So far we used to flatten the tuples produced by logical decoding in order to
write them to a temporary file. That means that all the TOASTed attributes
ended up in a single chunk of memory. The problem is that even if individual
attributes do fit into the maximum chunk size (currently 1 GB), the whole
tuple is not guaranteed to fit.

The flattening might be a problem in the future anyway, since there's an
effort to restrict the impact of REPACK (CONCURRENTLY) on the VACUUM xmin
horizon. However, as the flattening assumes scans of the TOAST relaation, the
less we restrict VACUUM, the more likely it is that the TOAST attributes
needed for the flattening won't be available at decoding time.

(This patch also removes unnecessary field 'tupdesc' from RepackDecodingState
and allocates it in the appropriate memory context.)
---
 src/backend/commands/cluster.c                | 260 +++++++++++++++---
 .../pgoutput_repack/pgoutput_repack.c         | 114 ++++++--
 src/include/commands/cluster.h                |   5 +-
 .../expected/repack_toast.out                 |   1 +
 .../injection_points/specs/repack_toast.spec  |   7 +
 5 files changed, 318 insertions(+), 69 deletions(-)

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index db710259eeb..e4de410e733 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -35,6 +35,7 @@
 #include "postgres.h"
 
 #include "access/amapi.h"
+#include "access/detoast.h"
 #include "access/heapam.h"
 #include "access/multixact.h"
 #include "access/relscan.h"
@@ -285,6 +286,10 @@ static void apply_concurrent_update(Relation rel, HeapTuple tup,
 									IndexInsertState *iistate,
 									TupleTableSlot *index_slot);
 static void apply_concurrent_delete(Relation rel, HeapTuple tup_target);
+static HeapTuple restore_tuple(BufFile *file, Relation relation,
+							   MemoryContext cxt);
+static HeapTuple adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+									   HeapTuple tup_src, MemoryContext cxt);
 static HeapTuple find_target_tuple(Relation rel, ChangeDest *dest,
 								   HeapTuple tup_key,
 								   TupleTableSlot *ident_slot);
@@ -2574,6 +2579,7 @@ setup_logical_decoding(Oid relid)
 	LogicalDecodingContext *ctx;
 	NameData	slotname;
 	RepackDecodingState *dstate;
+	MemoryContext oldcxt;
 
 	/*
 	 * REPACK CONCURRENTLY is not allowed in a transaction block, so this
@@ -2624,14 +2630,6 @@ setup_logical_decoding(Oid relid)
 	 */
 	ctx->reader->routine.page_read = read_local_xlog_page_no_wait;
 
-	/*
-	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
-	 * WAL.
-	 */
-	ctx->reader->private_data = MemoryContextAllocZero(ctx->context,
-													   sizeof(ReadLocalXLogPageNoWaitPrivate));
-
-
 	/* Some WAL records should have been read. */
 	Assert(ctx->reader->EndRecPtr != InvalidXLogRecPtr);
 
@@ -2642,18 +2640,23 @@ setup_logical_decoding(Oid relid)
 	XLByteToSeg(ctx->reader->EndRecPtr, repack_current_segment,
 				wal_segment_size);
 
-	dstate = palloc0_object(RepackDecodingState);
-	dstate->relid = relid;
+	/* Our private state belongs to the decoding context. */
+	oldcxt = MemoryContextSwitchTo(ctx->context);
 
 	/*
-	 * Tuple descriptor may be needed to flatten a tuple before we write it to
-	 * a file. A copy is needed because the decoding worker invalidates system
-	 * caches before it starts to do the actual work.
+	 * read_local_xlog_page_no_wait() needs to be able to indicate the end of
+	 * WAL.
 	 */
-	rel = table_open(relid, AccessShareLock);
-	dstate->tupdesc = CreateTupleDescCopy(RelationGetDescr(rel));
+	ctx->reader->private_data = palloc0_object(ReadLocalXLogPageNoWaitPrivate);
+	dstate = palloc0_object(RepackDecodingState);
+	MemoryContextSwitchTo(oldcxt);
+
+#ifdef	USE_ASSERT_CHECKING
+	dstate->relid = relid;
+#endif
 
 	/* Avoid logical decoding of other relations. */
+	rel = table_open(relid, AccessShareLock);
 	repacked_rel_locator = rel->rd_locator;
 	toastrelid = rel->rd_rel->reltoastrelid;
 	if (OidIsValid(toastrelid))
@@ -2822,10 +2825,10 @@ static void
 apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 {
 	char		kind;
-	uint32		t_len;
 	Relation	rel = dest->rel;
 	TupleTableSlot *index_slot,
 			   *ident_slot;
+	MemoryContext apply_cxt;
 	HeapTuple	tup_old = NULL;
 
 	/* TupleTableSlot is needed to pass the tuple to ExecInsertIndexTuples(). */
@@ -2835,6 +2838,14 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	/* A slot to fetch tuples from identity index. */
 	ident_slot = table_slot_create(rel, NULL);
 
+	/*
+	 * Use a separate memory context for the tuples and any memory needed to
+	 * process them.
+	 */
+	apply_cxt = AllocSetContextCreate(TopTransactionContext,
+									  "REPACK - apply",
+									  ALLOCSET_DEFAULT_SIZES);
+
 	while (true)
 	{
 		size_t		nread;
@@ -2849,14 +2860,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 			break;
 
 		/* Read the tuple. */
-		BufFileReadExact(file, &t_len, sizeof(t_len));
-		tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
-		tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
-		BufFileReadExact(file, tup->t_data, t_len);
-		tup->t_len = t_len;
-		ItemPointerSetInvalid(&tup->t_self);
-		tup->t_tableOid = RelationGetRelid(dest->rel);
-
+		tup = restore_tuple(file, rel, apply_cxt);
 		if (kind == CHANGE_UPDATE_OLD)
 		{
 			Assert(tup_old == NULL);
@@ -2868,7 +2872,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 
 			apply_concurrent_insert(rel, tup, dest->iistate, index_slot);
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else if (kind == CHANGE_UPDATE_NEW || kind == CHANGE_DELETE)
 		{
@@ -2892,18 +2896,28 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 				elog(ERROR, "failed to find target tuple");
 
 			if (kind == CHANGE_UPDATE_NEW)
+			{
+				/*
+				 * If 'tup' contains TOAST pointers, they point to the old
+				 * relation's toast. Copy the corresponding TOAST pointers for
+				 * the new relation from the existing tuple. (The fact that we
+				 * received a TOAST pointer here implies that the attribute
+				 * hasn't changed.)
+				 */
+				if (HeapTupleHasExternal(tup))
+					tup = adjust_toast_pointers(rel, tup, tup_exist,
+												apply_cxt);
+
 				apply_concurrent_update(rel, tup, tup_exist, dest->iistate,
 										index_slot);
+			}
 			else
 				apply_concurrent_delete(rel, tup_exist);
 
 			if (tup_old != NULL)
-			{
-				pfree(tup_old);
 				tup_old = NULL;
-			}
 
-			pfree(tup);
+			MemoryContextReset(apply_cxt);
 		}
 		else
 			elog(ERROR, "unrecognized kind of change: %d", kind);
@@ -2920,6 +2934,7 @@ apply_concurrent_changes(BufFile *file, ChangeDest *dest)
 	}
 
 	/* Cleanup. */
+	MemoryContextDelete(apply_cxt);
 	ExecDropSingleTupleTableSlot(index_slot);
 	ExecDropSingleTupleTableSlot(ident_slot);
 }
@@ -3030,6 +3045,186 @@ apply_concurrent_delete(Relation rel, HeapTuple tup_target)
 	pgstat_progress_incr_param(PROGRESS_REPACK_HEAP_TUPLES_DELETED, 1);
 }
 
+/*
+ * Read tuple from file and store it in given memory context.
+ *
+ * External attributes are stored in separate memory chunks, in order to avoid
+ * exceeding MaxAllocSize - that could happen if the individual attributes are
+ * smaller than MaxAllocSize but the whole tuple is bigger.
+ */
+static HeapTuple
+restore_tuple(BufFile *file, Relation relation, MemoryContext cxt)
+{
+	uint32		t_len;
+	HeapTuple	tup;
+	MemoryContext oldcxt;
+	uint32		natt_ext;
+	List	   *attrs_ext = NIL;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	/* First, read the external attributes if there are some. */
+	BufFileReadExact(file, &natt_ext, sizeof(natt_ext));
+	for (int i = 0; i < natt_ext; i++)
+	{
+		varlena		varhdr;
+		char	   *ext_val;
+		Size		ext_val_size;
+
+		/*
+		 * Read the header into properly aligned memory before accessing it.
+		 */
+		BufFileReadExact(file, &varhdr, VARHDRSZ);
+		ext_val_size = VARSIZE_ANY(&varhdr);
+		ext_val = palloc0(ext_val_size);
+		memcpy(ext_val, &varhdr, VARHDRSZ);
+		BufFileReadExact(file, ext_val + VARHDRSZ, ext_val_size - VARHDRSZ);
+
+		attrs_ext = lappend(attrs_ext, ext_val);
+	}
+
+	/* Read the tuple. */
+	BufFileReadExact(file, &t_len, sizeof(t_len));
+	tup = (HeapTuple) palloc(HEAPTUPLESIZE + t_len);
+	tup->t_data = (HeapTupleHeader) ((char *) tup + HEAPTUPLESIZE);
+	BufFileReadExact(file, tup->t_data, t_len);
+	tup->t_len = t_len;
+	ItemPointerSetInvalid(&tup->t_self);
+	tup->t_tableOid = RelationGetRelid(relation);
+
+	/*
+	 * If there are "external indirect" attributes, make the tuple reference
+	 * them.
+	 */
+	if (natt_ext > 0)
+	{
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+		ListCell   *lc;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tup, desc, attrs, isnull);
+
+		lc = list_head(attrs_ext);
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer,
+					   *new_datum;
+			varatt_indirect redirect_pointer;
+
+			/* Find the external attributes, like in store_change(). */
+			if (attr->attisdropped)
+				continue;
+			if (attr->attlen != -1)
+				continue;
+			if (isnull[i])
+				continue;
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+			if (!VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				continue;
+
+			/* Update the attribute. */
+			memset(&redirect_pointer, 0, sizeof(redirect_pointer));
+			redirect_pointer.pointer = lfirst(lc);
+
+			new_datum = (varlena *) palloc0(INDIRECT_POINTER_SIZE);
+			SET_VARTAG_EXTERNAL(new_datum, VARTAG_INDIRECT);
+			memcpy(VARDATA_EXTERNAL(new_datum), &redirect_pointer,
+				   sizeof(redirect_pointer));
+
+			attrs[i] = PointerGetDatum(new_datum);
+
+			lc = lnext(attrs_ext, lc);
+		}
+		Assert(lc == NULL);
+
+		tup = heap_form_tuple(desc, attrs, isnull);
+	}
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return tup;
+}
+
+/*
+ * Copy TOAST pointers from 'tup_src' to 'tup_dst' and return the modified
+ * 'tup_dst'. Use 'cxt' for all memory allocations.
+ */
+static HeapTuple
+adjust_toast_pointers(Relation relation, HeapTuple tup_dst,
+					  HeapTuple tup_src, MemoryContext cxt)
+{
+	TupleDesc	desc;
+	Datum	   *attrs_dst;
+	bool	   *isnull_dst;
+	Datum	   *attrs_src = NULL;
+	bool	   *isnull_src = NULL;
+	MemoryContext oldcxt;
+	HeapTuple	result;
+
+	oldcxt = MemoryContextSwitchTo(cxt);
+
+	desc = RelationGetDescr(relation);
+	attrs_dst = palloc0_array(Datum, desc->natts);
+	isnull_dst = palloc0_array(bool, desc->natts);
+
+	heap_deform_tuple(tup_dst, desc, attrs_dst, isnull_dst);
+
+	for (int i = 0; i < desc->natts; i++)
+	{
+		CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+		varlena    *varlena_dst,
+				   *varlena_src;
+
+		if (attr->attisdropped)
+			continue;
+		if (attr->attlen != -1)
+			continue;
+		if (isnull_dst[i])
+			continue;
+
+		varlena_dst = (varlena *) DatumGetPointer(attrs_dst[i]);
+		if (!VARATT_IS_EXTERNAL_ONDISK(varlena_dst))
+			continue;
+
+		/*
+		 * The first TOAST pointer? The caller can easily check if the tuple
+		 * has external attributes(s) in general, but is not supposed to check
+		 * specifically for TOAST.
+		 */
+		if (attrs_src == NULL)
+		{
+			attrs_src = palloc0_array(Datum, desc->natts);
+			isnull_src = palloc0_array(bool, desc->natts);
+
+			heap_deform_tuple(tup_src, desc, attrs_src, isnull_src);
+		}
+
+		varlena_src = (varlena *) DatumGetPointer(attrs_src[i]);
+
+		/*
+		 * Logical decoding only uses TOAST pointer for attributes that
+		 * haven't changed.
+		 */
+		Assert(!isnull_src[i]);
+		Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_src));
+
+		/* Copy the pointer. */
+		memcpy(VARDATA_EXTERNAL(varlena_dst), VARDATA_EXTERNAL(varlena_src),
+			   sizeof(varatt_external));
+	}
+	result = heap_form_tuple(desc, attrs_dst, isnull_dst);
+
+	MemoryContextSwitchTo(oldcxt);
+
+	return result;
+}
+
 /*
  * Find the tuple to be updated or deleted.
  *
@@ -3263,15 +3458,8 @@ free_index_insert_state(IndexInsertState *iistate)
 static void
 cleanup_logical_decoding(LogicalDecodingContext *ctx)
 {
-	RepackDecodingState *dstate;
-
-	dstate = (RepackDecodingState *) ctx->output_writer_private;
-
-	FreeTupleDesc(dstate->tupdesc);
 	FreeDecodingContext(ctx);
-
 	ReplicationSlotDropAcquired();
-	pfree(dstate);
 }
 
 /*
diff --git a/src/backend/replication/pgoutput_repack/pgoutput_repack.c b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
index d0c464a98d5..8e22aeb163b 100644
--- a/src/backend/replication/pgoutput_repack/pgoutput_repack.c
+++ b/src/backend/replication/pgoutput_repack/pgoutput_repack.c
@@ -12,7 +12,7 @@
  */
 #include "postgres.h"
 
-#include "access/heaptoast.h"
+#include "access/detoast.h"
 #include "commands/cluster.h"
 #include "replication/snapbuild.h"
 #include "utils/memutils.h"
@@ -28,7 +28,7 @@ static void plugin_commit_txn(LogicalDecodingContext *ctx,
 							  ReorderBufferTXN *txn, XLogRecPtr commit_lsn);
 static void plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 						  Relation rel, ReorderBufferChange *change);
-static void store_change(LogicalDecodingContext *ctx,
+static void store_change(LogicalDecodingContext *ctx, Relation relation,
 						 ConcurrentChangeKind kind, HeapTuple tuple);
 
 void
@@ -97,9 +97,8 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
 
-	/* Only interested in one particular relation. */
-	if (relation->rd_id != dstate->relid)
-		return;
+	/* Changes of other relation should not have been decoded. */
+	Assert(RelationGetRelid(relation) == dstate->relid);
 
 	/* Decode entry depending on its type */
 	switch (change->action)
@@ -117,7 +116,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (newtuple == NULL)
 					elog(ERROR, "incomplete insert info.");
 
-				store_change(ctx, CHANGE_INSERT, newtuple);
+				store_change(ctx, relation, CHANGE_INSERT, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_UPDATE:
@@ -132,9 +131,9 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 					elog(ERROR, "incomplete update info.");
 
 				if (oldtuple != NULL)
-					store_change(ctx, CHANGE_UPDATE_OLD, oldtuple);
+					store_change(ctx, relation, CHANGE_UPDATE_OLD, oldtuple);
 
-				store_change(ctx, CHANGE_UPDATE_NEW, newtuple);
+				store_change(ctx, relation, CHANGE_UPDATE_NEW, newtuple);
 			}
 			break;
 		case REORDER_BUFFER_CHANGE_DELETE:
@@ -146,7 +145,7 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 				if (oldtuple == NULL)
 					elog(ERROR, "incomplete delete info.");
 
-				store_change(ctx, CHANGE_DELETE, oldtuple);
+				store_change(ctx, relation, CHANGE_DELETE, oldtuple);
 			}
 			break;
 		default:
@@ -164,39 +163,94 @@ plugin_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
 
 /* Store concurrent data change. */
 static void
-store_change(LogicalDecodingContext *ctx, ConcurrentChangeKind kind,
-			 HeapTuple tuple)
+store_change(LogicalDecodingContext *ctx, Relation relation,
+			 ConcurrentChangeKind kind, HeapTuple tuple)
 {
 	RepackDecodingState *dstate;
+	BufFile    *file;
 	char		kind_byte = (char) kind;
-	bool		flattened = false;
+	List	   *attrs_ext = NIL;
+	uint32		natt_ext;
 
 	dstate = (RepackDecodingState *) ctx->output_writer_private;
+	file = dstate->file;
 
 	/* Store the change kind. */
-	BufFileWrite(dstate->file, &kind_byte, 1);
+	BufFileWrite(file, &kind_byte, 1);
 
 	/*
-	 * ReorderBufferCommit() stores the TOAST chunks in its private memory
-	 * context and frees them after having called apply_change().  Therefore
-	 * we need flat copy (including TOAST) that we eventually copy into the
-	 * memory context which is available to decode_concurrent_changes().
+	 * If the tuple contains "external indirect" attributes, we need to write
+	 * the contents to the file because we have no control over that memory.
 	 */
 	if (HeapTupleHasExternal(tuple))
 	{
-		/*
-		 * toast_flatten_tuple_to_datum() might be more convenient but we
-		 * don't want the decompression it does.
-		 */
-		tuple = toast_flatten_tuple(tuple, dstate->tupdesc);
-		flattened = true;
+		TupleDesc	desc;
+		Datum	   *attrs;
+		bool	   *isnull;
+
+		desc = RelationGetDescr(relation);
+		attrs = palloc0_array(Datum, desc->natts);
+		isnull = palloc0_array(bool, desc->natts);
+
+		heap_deform_tuple(tuple, desc, attrs, isnull);
+
+		/* First, gather and count the "external indirect" attributes. */
+		for (int i = 0; i < desc->natts; i++)
+		{
+			CompactAttribute *attr = TupleDescCompactAttr(desc, i);
+			varlena    *varlena_pointer;
+
+			if (attr->attisdropped)
+				continue;
+
+			/* not a varlena datatype */
+			if (attr->attlen != -1)
+				continue;
+
+			/* no data */
+			if (isnull[i])
+				continue;
+
+			/* ok, we know we have a toast datum */
+			varlena_pointer = (varlena *) DatumGetPointer(attrs[i]);
+
+			if (!VARATT_IS_EXTERNAL(varlena_pointer))
+				continue;
+
+			if (VARATT_IS_EXTERNAL_INDIRECT(varlena_pointer))
+				attrs_ext = lappend(attrs_ext, varlena_pointer);
+			else
+			{
+				/*
+				 * Logical decoding should not produce "external expanded"
+				 * attributes (those actually should never appear on disk), so
+				 * only TOASTed attribute can be seen here.
+				 */
+				Assert(VARATT_IS_EXTERNAL_ONDISK(varlena_pointer));
+			}
+		}
+		natt_ext = list_length(attrs_ext);
 	}
-	/* Store the tuple size ... */
-	BufFileWrite(dstate->file, &tuple->t_len, sizeof(tuple->t_len));
-	/* ... and the tuple itself. */
-	BufFileWrite(dstate->file, tuple->t_data, tuple->t_len);
+	else
+		natt_ext = 0;
 
-	/* Free the flat copy if created above. */
-	if (flattened)
-		pfree(tuple);
+	/* Write the number of external attributes. */
+	BufFileWrite(file, &natt_ext, sizeof(natt_ext));
+	/* ... and the attributes themselves, if there are some. */
+	foreach_ptr(varlena, attr_val, attrs_ext)
+	{
+		varlena    *ext_val;
+		Size		ext_val_size;
+
+		ext_val = detoast_external_attr(attr_val);
+		ext_val_size = VARSIZE_ANY(ext_val);
+		BufFileWrite(file, ext_val, ext_val_size);
+		pfree(ext_val);
+	}
+	list_free(attrs_ext);
+
+	/* Finally write the tuple size ... */
+	BufFileWrite(file, &tuple->t_len, sizeof(tuple->t_len));
+	/* ... and the tuple itself. */
+	BufFileWrite(file, tuple->t_data, tuple->t_len);
 }
diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 1b05d5d418b..a32813e8530 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -65,11 +65,10 @@ typedef enum
  */
 typedef struct RepackDecodingState
 {
+#ifdef	USE_ASSERT_CHECKING
 	/* The relation whose changes we're decoding. */
 	Oid			relid;
-
-	/* Tuple descriptor of the relation being processed. */
-	TupleDesc	tupdesc;
+#endif
 
 	/* The current output file. */
 	BufFile    *file;
diff --git a/src/test/modules/injection_points/expected/repack_toast.out b/src/test/modules/injection_points/expected/repack_toast.out
index 4f866a74e32..b56dde134f8 100644
--- a/src/test/modules/injection_points/expected/repack_toast.out
+++ b/src/test/modules/injection_points/expected/repack_toast.out
@@ -13,6 +13,7 @@ step change:
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 
 step check2: 
 	INSERT INTO relfilenodes(node)
diff --git a/src/test/modules/injection_points/specs/repack_toast.spec b/src/test/modules/injection_points/specs/repack_toast.spec
index b48abf21450..f84917daca2 100644
--- a/src/test/modules/injection_points/specs/repack_toast.spec
+++ b/src/test/modules/injection_points/specs/repack_toast.spec
@@ -74,10 +74,17 @@ teardown
 
 session s2
 step change
+# Separately test UPDATE of both plain ("i") and TOASTed ("j") attribute. In
+# the first case, the new tuple we get from reorderbuffer.c contains "j" as a
+# TOAST pointer, wich we need to update so it points to the new heap. In the
+# latter case, we receive "j" as "external indirect" value - here we test that
+# the decoding worker writes the tuple to a file correctly and that the
+# backend executing REPACK manages to restore it.
 {
 	UPDATE repack_test SET j=get_long_string() where i=2;
 	DELETE FROM repack_test WHERE i=3;
 	INSERT INTO repack_test(i, j) VALUES (4, get_long_string());
+	UPDATE repack_test SET i=3 where i=1;
 }
 # Check the table from the perspective of s2.
 step check2
-- 
2.47.3


--=-=-=--





^ permalink  raw  reply  [nested|flat] 226+ messages in thread