agora inbox for [email protected]  

help / color / mirror / Atom feed

[PATCH v29 02/11] Add relisivm column to pg_class system catalog
332+ messages / 2 participants
[nested] [flat]

* [PATCH v29 02/11] Add relisivm column to pg_class system catalog
@ 2019-12-20 01:07  Yugo Nagata <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Yugo Nagata @ 2019-12-20 01:07 UTC (permalink / raw)

If this boolean column is true, a relations is Incrementally Maintainable
Materialized View (IMMV). This is set when IMMV is created.

Also, isimmv columns is added to pg_matviews system view.

isimmv
---
 src/backend/catalog/heap.c           |  1 +
 src/backend/catalog/index.c          |  1 +
 src/backend/catalog/system_views.sql |  1 +
 src/backend/utils/cache/lsyscache.c  | 24 ++++++++++++++++++++++++
 src/backend/utils/cache/relcache.c   |  2 ++
 src/include/catalog/pg_class.h       |  3 +++
 src/include/utils/lsyscache.h        |  1 +
 src/include/utils/rel.h              |  2 ++
 src/test/regress/expected/rules.out  |  1 +
 9 files changed, 36 insertions(+)

diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index b534da7d80..d9eac41463 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -924,6 +924,7 @@ InsertPgClassTuple(Relation pg_class_desc,
 	values[Anum_pg_class_relrewrite - 1] = ObjectIdGetDatum(rd_rel->relrewrite);
 	values[Anum_pg_class_relfrozenxid - 1] = TransactionIdGetDatum(rd_rel->relfrozenxid);
 	values[Anum_pg_class_relminmxid - 1] = MultiXactIdGetDatum(rd_rel->relminmxid);
+	values[Anum_pg_class_relisivm - 1] = BoolGetDatum(rd_rel->relisivm);
 	if (relacl != (Datum) 0)
 		values[Anum_pg_class_relacl - 1] = relacl;
 	else
diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index fd09378848..e4b52fdd21 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -993,6 +993,7 @@ index_create(Relation heapRelation,
 	indexRelation->rd_rel->relowner = heapRelation->rd_rel->relowner;
 	indexRelation->rd_rel->relam = accessMethodId;
 	indexRelation->rd_rel->relispartition = OidIsValid(parentIndexRelid);
+	indexRelation->rd_rel->relisivm = false;
 
 	/*
 	 * store index's pg_class entry
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 77b06e2a7a..2b60ed9e52 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -146,6 +146,7 @@ CREATE VIEW pg_matviews AS
         T.spcname AS tablespace,
         C.relhasindex AS hasindexes,
         C.relispopulated AS ispopulated,
+        C.relisivm AS isimmv,
         pg_get_viewdef(C.oid) AS definition
     FROM pg_class C LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
          LEFT JOIN pg_tablespace T ON (T.oid = C.reltablespace)
diff --git a/src/backend/utils/cache/lsyscache.c b/src/backend/utils/cache/lsyscache.c
index fc6d267e44..2b29ab4409 100644
--- a/src/backend/utils/cache/lsyscache.c
+++ b/src/backend/utils/cache/lsyscache.c
@@ -2046,6 +2046,30 @@ get_rel_relispartition(Oid relid)
 		return false;
 }
 
+/*
+ * get_rel_relisivm
+ *
+ *		Returns the relisivm flag associated with a given relation.
+ */
+bool
+get_rel_relisivm(Oid relid)
+{
+	HeapTuple	tp;
+
+	tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+	if (HeapTupleIsValid(tp))
+	{
+		Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
+		bool		result;
+
+		result = reltup->relisivm;
+		ReleaseSysCache(tp);
+		return result;
+	}
+	else
+		return false;
+}
+
 /*
  * get_rel_tablespace
  *
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 7234cb3da6..96cd510780 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -1924,6 +1924,8 @@ formrdesc(const char *relationName, Oid relationReltype,
 
 	/* ... and they're always populated, too */
 	relation->rd_rel->relispopulated = true;
+	/* ... and they're always no ivm, too */
+	relation->rd_rel->relisivm = false;
 
 	relation->rd_rel->relreplident = REPLICA_IDENTITY_NOTHING;
 	relation->rd_rel->relpages = 0;
diff --git a/src/include/catalog/pg_class.h b/src/include/catalog/pg_class.h
index 2d1bb7af3a..62b9c0e5cb 100644
--- a/src/include/catalog/pg_class.h
+++ b/src/include/catalog/pg_class.h
@@ -119,6 +119,9 @@ CATALOG(pg_class,1259,RelationRelationId) BKI_BOOTSTRAP BKI_ROWTYPE_OID(83,Relat
 	/* is relation a partition? */
 	bool		relispartition BKI_DEFAULT(f);
 
+	/* is relation a matview with ivm? */
+	bool		relisivm BKI_DEFAULT(f);
+
 	/* link to original rel during table rewrite; otherwise 0 */
 	Oid			relrewrite BKI_DEFAULT(0) BKI_LOOKUP_OPT(pg_class);
 
diff --git a/src/include/utils/lsyscache.h b/src/include/utils/lsyscache.h
index f5fdbfe116..7b433749f5 100644
--- a/src/include/utils/lsyscache.h
+++ b/src/include/utils/lsyscache.h
@@ -138,6 +138,7 @@ extern Oid	get_rel_namespace(Oid relid);
 extern Oid	get_rel_type_id(Oid relid);
 extern char get_rel_relkind(Oid relid);
 extern bool get_rel_relispartition(Oid relid);
+extern bool get_rel_relisivm(Oid relid);
 extern Oid	get_rel_tablespace(Oid relid);
 extern char get_rel_persistence(Oid relid);
 extern Oid	get_transform_fromsql(Oid typid, Oid langid, List *trftypes);
diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h
index 1426a353cd..b8961176bb 100644
--- a/src/include/utils/rel.h
+++ b/src/include/utils/rel.h
@@ -677,6 +677,8 @@ RelationCloseSmgr(Relation relation)
  */
 #define RelationIsPopulated(relation) ((relation)->rd_rel->relispopulated)
 
+#define RelationIsIVM(relation) ((relation)->rd_rel->relisivm)
+
 /*
  * RelationIsAccessibleInLogicalDecoding
  *		True if we need to log enough information to have access via
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index 5058be5411..cc5287344d 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1392,6 +1392,7 @@ pg_matviews| SELECT n.nspname AS schemaname,
     t.spcname AS tablespace,
     c.relhasindex AS hasindexes,
     c.relispopulated AS ispopulated,
+    c.relisivm AS isimmv,
     pg_get_viewdef(c.oid) AS definition
    FROM ((pg_class c
      LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace)))
-- 
2.25.1


--Multipart=_Mon__28_Aug_2023_16_05_30_+0900_b1OvQD_3A3ZMTGvj
Content-Type: text/x-diff;
 name="v29-0003-Allow-to-prolong-life-span-of-transition-tables-.patch"
Content-Disposition: attachment;
 filename="v29-0003-Allow-to-prolong-life-span-of-transition-tables-.patch"
Content-Transfer-Encoding: 7bit



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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

* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files().
@ 2026-06-16 11:54  Antonin Houska <[email protected]>
  0 siblings, 0 replies; 332+ messages in thread

From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw)

So far, the relfrozenxid and relminmxid attributes of pg_class used to be
updated by swap_relation_files(), however, not every call of the function
should do that. On the contrary, new feature of REPACK (CONCURRENTLY) will
need to update this information in one case that would be tricky to handle
using swap_relation_files().
---
 src/backend/commands/repack.c | 114 +++++++++++++++++-----------------
 1 file changed, 56 insertions(+), 58 deletions(-)

diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c
index 6f3e4ecff46..92c1b678e6f 100644
--- a/src/backend/commands/repack.c
+++ b/src/backend/commands/repack.c
@@ -186,6 +186,8 @@ static void copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldInde
 							TransactionId *pFreezeXid,
 							MultiXactId *pCutoffMulti,
 							ChangeContext *chgcxt);
+static void update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+									MultiXactId cutoffMulti);
 static List *get_tables_to_repack(RepackCommand cmd, bool usingindex,
 								  MemoryContext permcxt);
 static List *get_tables_to_repack_partitioned(RepackCommand cmd,
@@ -2014,13 +2016,6 @@ copy_table_data(Relation NewHeap, Relation OldHeap, Relation OldIndex,
  * links) while the latter is the only way to handle cases in which a toast
  * table is added or removed altogether.
  *
- * Additionally, the first relation is marked with relfrozenxid set to
- * frozenXid.  It seems a bit ugly to have this here, but the caller would
- * have to do it anyway, so having it here saves a heap_update.  Note: in
- * the swap-toast-links case, we assume we don't need to change the toast
- * table's relfrozenxid: the new version of the toast table should already
- * have relfrozenxid set to RecentXmin, which is good enough.
- *
  * Lastly, if r2 and its toast table and toast index (if any) are mapped,
  * their OIDs are emitted into mapped_tables[].  This is hacky but beats
  * having to look the information up again later in finish_heap_swap.
@@ -2029,9 +2024,7 @@ static void
 swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 					bool swap_toast_by_content,
 					bool is_internal,
-					TransactionId frozenXid,
-					MultiXactId cutoffMulti,
-					Oid *mapped_tables)
+					Oid *mapped_tables, Oid *r1_toastid)
 {
 	Relation	relRelation;
 	HeapTuple	reltup1,
@@ -2063,6 +2056,9 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	relam1 = relform1->relam;
 	relam2 = relform2->relam;
 
+	if (r1_toastid)
+		*r1_toastid = relform1->reltoastrelid;
+
 	if (RelFileNumberIsValid(relfilenumber1) &&
 		RelFileNumberIsValid(relfilenumber2))
 	{
@@ -2178,15 +2174,6 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	 * and then fail to commit the pg_class update.
 	 */
 
-	/* set rel1's frozen Xid and minimum MultiXid */
-	if (relform1->relkind != RELKIND_INDEX)
-	{
-		Assert(!TransactionIdIsValid(frozenXid) ||
-			   TransactionIdIsNormal(frozenXid));
-		relform1->relfrozenxid = frozenXid;
-		relform1->relminmxid = cutoffMulti;
-	}
-
 	/* swap size statistics too, since new rel has freshly-updated stats */
 	{
 		int32		swap_pages;
@@ -2288,9 +2275,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 									target_is_pg_class,
 									swap_toast_by_content,
 									is_internal,
-									frozenXid,
-									cutoffMulti,
-									mapped_tables);
+									mapped_tables,
+									NULL);
 			}
 			else
 			{
@@ -2391,9 +2377,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 							target_is_pg_class,
 							swap_toast_by_content,
 							is_internal,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 	}
 
 	/* Clean up. */
@@ -2403,6 +2388,36 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 	table_close(relRelation, RowExclusiveLock);
 }
 
+/*
+ * Update relfrozenxid and relminmxid attributes of pg_class entry, specified
+ * by OID.
+ */
+static void
+update_relation_cutoffs(Oid relid, TransactionId frozenXid,
+						MultiXactId cutoffMulti)
+{
+	Relation	relRelation;
+	HeapTuple	reltup;
+	Form_pg_class relform;
+	CatalogIndexState indstate;
+
+	relRelation = table_open(RelationRelationId, RowExclusiveLock);
+	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relid));
+	if (!HeapTupleIsValid(reltup))
+		elog(ERROR, "cache lookup failed for relation %u", relid);
+	relform = (Form_pg_class) GETSTRUCT(reltup);
+	relform->relfrozenxid = frozenXid;
+	relform->relminmxid = cutoffMulti;
+
+	indstate = CatalogOpenIndexes(relRelation);
+	CatalogTupleUpdateWithInfo(relRelation, &reltup->t_self, reltup,
+							   indstate);
+	CatalogCloseIndexes(indstate);
+
+	heap_freetuple(reltup);
+	table_close(relRelation, RowExclusiveLock);
+}
+
 /*
  * Remove the transient table that was built by make_new_heap, and finish
  * cleaning up (including rebuilding all indexes on the old heap).
@@ -2420,6 +2435,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 {
 	ObjectAddress object;
 	Oid			mapped_tables[4];
+	Oid			oid_old_toastid;
 	int			i;
 
 	/* Report that we are now swapping relation files */
@@ -2436,7 +2452,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 	swap_relation_files(OIDOldHeap, OIDNewHeap,
 						(OIDOldHeap == RelationRelationId),
 						swap_toast_by_content, is_internal,
-						frozenXid, cutoffMulti, mapped_tables);
+						mapped_tables, &oid_old_toastid);
 
 	/*
 	 * If it's a system catalog, queue a sinval message to flush all catcaches
@@ -2492,37 +2508,20 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
 								 PROGRESS_REPACK_PHASE_FINAL_CLEANUP);
 
 	/*
-	 * If the relation being rebuilt is pg_class, swap_relation_files()
-	 * couldn't update pg_class's own pg_class entry (check comments in
-	 * swap_relation_files()), thus relfrozenxid was not updated. That's
-	 * annoying because a potential reason for doing a VACUUM FULL is a
-	 * imminent or actual anti-wraparound shutdown.  So, now that we can
-	 * access the new relation using its indices, update relfrozenxid.
-	 * pg_class doesn't have a toast relation, so we don't need to update the
-	 * corresponding toast relation. Not that there's little point moving all
-	 * relfrozenxid updates here since swap_relation_files() needs to write to
-	 * pg_class for non-mapped relations anyway.
+	 * Update relfrozenxid and relminmxid. CCI is needed to see the most
+	 * recent pg_class tuple, created by swap_relation_files(). However that
+	 * CCI makes us use the new relation file. Therefore we cannot do this
+	 * before indexes have been rebuilt too.
 	 */
-	if (OIDOldHeap == RelationRelationId)
-	{
-		Relation	relRelation;
-		HeapTuple	reltup;
-		Form_pg_class relform;
-
-		relRelation = table_open(RelationRelationId, RowExclusiveLock);
-
-		reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap));
-		if (!HeapTupleIsValid(reltup))
-			elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap);
-		relform = (Form_pg_class) GETSTRUCT(reltup);
-
-		relform->relfrozenxid = frozenXid;
-		relform->relminmxid = cutoffMulti;
-
-		CatalogTupleUpdate(relRelation, &reltup->t_self, reltup);
+	CommandCounterIncrement();
+	update_relation_cutoffs(OIDOldHeap, frozenXid, cutoffMulti);
 
-		table_close(relRelation, RowExclusiveLock);
-	}
+	/*
+	 * The same for TOAST, if needed. In the swap-toast-links case, the new
+	 * the toast table should already have relfrozenxid set to RecentXmin.
+	 */
+	if (OidIsValid(oid_old_toastid) && swap_toast_by_content)
+		update_relation_cutoffs(oid_old_toastid, frozenXid, cutoffMulti);
 
 	/* Destroy new heap with old filenumber */
 	object.classId = RelationRelationId;
@@ -4072,9 +4071,8 @@ rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap,
 							(old_table_oid == RelationRelationId),
 							false,	/* swap_toast_by_content */
 							true,
-							InvalidTransactionId,
-							InvalidMultiXactId,
-							mapped_tables);
+							mapped_tables,
+							NULL);
 
 #ifdef USE_ASSERT_CHECKING
 
-- 
2.52.0


--=-=-=
Content-Type: text/plain
Content-Disposition: attachment;
 filename=v01-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch



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