agora inbox for [email protected]help / color / mirror / Atom feed
[PATCH v51 10/10] CheckLogicalDecodingRequirements: be specific about which GUC is limiting 100+ messages / 2 participants [nested] [flat]
* [PATCH v51 10/10] CheckLogicalDecodingRequirements: be specific about which GUC is limiting @ 2026-04-03 19:01 Álvaro Herrera <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Álvaro Herrera @ 2026-04-03 19:01 UTC (permalink / raw) --- src/backend/commands/repack_worker.c | 3 ++- src/backend/replication/logical/logical.c | 8 +++++--- src/backend/replication/logical/logicalfuncs.c | 2 +- src/backend/replication/slot.c | 18 ++++++++++++------ src/backend/replication/slotfuncs.c | 11 ++++++----- src/backend/replication/walsender.c | 5 +++-- src/include/replication/logical.h | 3 ++- src/include/replication/slot.h | 2 +- 8 files changed, 32 insertions(+), 20 deletions(-) diff --git a/src/backend/commands/repack_worker.c b/src/backend/commands/repack_worker.c index 610592a05b0..ca827223845 100644 --- a/src/backend/commands/repack_worker.c +++ b/src/backend/commands/repack_worker.c @@ -224,7 +224,7 @@ repack_setup_logical_decoding(Oid relid) * Make sure we can use logical decoding. */ CheckSlotPermissions(); - CheckLogicalDecodingRequirements(); + CheckLogicalDecodingRequirements(true); /* * A single backend should not execute multiple REPACK commands at a time, @@ -252,6 +252,7 @@ repack_setup_logical_decoding(Oid relid) ctx = CreateInitDecodingContext(REPL_PLUGIN_NAME, NIL, true, + true, InvalidXLogRecPtr, XL_ROUTINE(.page_read = read_local_xlog_page, .segment_open = wal_segment_open, diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c index f20a0fe70ad..a08aece5731 100644 --- a/src/backend/replication/logical/logical.c +++ b/src/backend/replication/logical/logical.c @@ -108,9 +108,9 @@ static void LoadOutputPlugin(OutputPluginCallbacks *callbacks, const char *plugi * decoding. */ void -CheckLogicalDecodingRequirements(void) +CheckLogicalDecodingRequirements(bool repack) { - CheckSlotRequirements(); + CheckSlotRequirements(repack); /* * NB: Adding a new requirement likely means that RestoreSlotFromDisk() @@ -305,6 +305,7 @@ StartupDecodingContext(List *output_plugin_options, * output_plugin_options -- contains options passed to the output plugin * need_full_snapshot -- if true, must obtain a snapshot able to read all * tables; if false, one that can read only catalogs is acceptable. + * for_repack -- if true, we're going to be decoding for REPACK. * restart_lsn -- if given as invalid, it's this routine's responsibility to * mark WAL as reserved by setting a convenient restart_lsn for the slot. * Otherwise, we set for decoding to start from the given LSN without @@ -325,6 +326,7 @@ LogicalDecodingContext * CreateInitDecodingContext(const char *plugin, List *output_plugin_options, bool need_full_snapshot, + bool for_repack, XLogRecPtr restart_lsn, XLogReaderRoutine *xl_routine, LogicalOutputPluginWriterPrepareWrite prepare_write, @@ -341,7 +343,7 @@ CreateInitDecodingContext(const char *plugin, * On a standby, this check is also required while creating the slot. * Check the comments in the function. */ - CheckLogicalDecodingRequirements(); + CheckLogicalDecodingRequirements(for_repack); /* shorter lines... */ slot = MyReplicationSlot; diff --git a/src/backend/replication/logical/logicalfuncs.c b/src/backend/replication/logical/logicalfuncs.c index 9760818941d..512013b0ef0 100644 --- a/src/backend/replication/logical/logicalfuncs.c +++ b/src/backend/replication/logical/logicalfuncs.c @@ -115,7 +115,7 @@ pg_logical_slot_get_changes_guts(FunctionCallInfo fcinfo, bool confirm, bool bin CheckSlotPermissions(); - CheckLogicalDecodingRequirements(); + CheckLogicalDecodingRequirements(false); if (PG_ARGISNULL(0)) ereport(ERROR, diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c index 2c6c6773ad2..13004ed547a 100644 --- a/src/backend/replication/slot.c +++ b/src/backend/replication/slot.c @@ -1669,19 +1669,25 @@ CheckLogicalSlotExists(void) * slots. */ void -CheckSlotRequirements(void) +CheckSlotRequirements(bool repack) { + int limit; + /* * NB: Adding a new requirement likely means that RestoreSlotFromDisk() * needs the same check. */ - /* XXX we should be able to check exactly which type of slot we need */ - if (max_replication_slots + max_repack_replication_slots == 0) + if (repack) + limit = max_repack_replication_slots; + else + limit = max_replication_slots; + + if (limit == 0) ereport(ERROR, - (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), - errmsg("replication slots can only be used if \"%s\" > 0 or \"%s\" > 0", - "max_replication_slots", "max_repack_replication_slots"))); + errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), + errmsg("replication slots can only be used if \"%s\" > 0", + repack ? "max_repack_replication_slots" : "max_replication_slots")); if (wal_level < WAL_LEVEL_REPLICA) ereport(ERROR, diff --git a/src/backend/replication/slotfuncs.c b/src/backend/replication/slotfuncs.c index 78dd3c4ea66..16fbd383735 100644 --- a/src/backend/replication/slotfuncs.c +++ b/src/backend/replication/slotfuncs.c @@ -90,7 +90,7 @@ pg_create_physical_replication_slot(PG_FUNCTION_ARGS) CheckSlotPermissions(); - CheckSlotRequirements(); + CheckSlotRequirements(false); create_physical_replication_slot(NameStr(*name), immediately_reserve, @@ -164,6 +164,7 @@ create_logical_replication_slot(char *name, char *plugin, */ ctx = CreateInitDecodingContext(plugin, NIL, false, /* just catalogs is OK */ + false, /* not repack */ restart_lsn, XL_ROUTINE(.page_read = read_local_xlog_page, .segment_open = wal_segment_open, @@ -203,7 +204,7 @@ pg_create_logical_replication_slot(PG_FUNCTION_ARGS) CheckSlotPermissions(); - CheckLogicalDecodingRequirements(); + CheckLogicalDecodingRequirements(false); create_logical_replication_slot(NameStr(*name), NameStr(*plugin), @@ -240,7 +241,7 @@ pg_drop_replication_slot(PG_FUNCTION_ARGS) CheckSlotPermissions(); - CheckSlotRequirements(); + CheckSlotRequirements(false); ReplicationSlotDrop(NameStr(*name), true); @@ -648,9 +649,9 @@ copy_replication_slot(FunctionCallInfo fcinfo, bool logical_slot) CheckSlotPermissions(); if (logical_slot) - CheckLogicalDecodingRequirements(); + CheckLogicalDecodingRequirements(false); else - CheckSlotRequirements(); + CheckSlotRequirements(false); LWLockAcquire(ReplicationSlotControlLock, LW_SHARED); diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index 75ef3419a15..9d7d675fa96 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -1240,7 +1240,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd) Assert(cmd->kind == REPLICATION_KIND_LOGICAL); - CheckLogicalDecodingRequirements(); + CheckLogicalDecodingRequirements(false); /* * Initially create persistent slot as ephemeral - that allows us to @@ -1309,6 +1309,7 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd) Assert(IsLogicalDecodingEnabled()); ctx = CreateInitDecodingContext(cmd->plugin, NIL, need_full_snapshot, + false, InvalidXLogRecPtr, XL_ROUTINE(.page_read = logical_read_xlog_page, .segment_open = WalSndSegmentOpen, @@ -1466,7 +1467,7 @@ StartLogicalReplication(StartReplicationCmd *cmd) QueryCompletion qc; /* make sure that our requirements are still fulfilled */ - CheckLogicalDecodingRequirements(); + CheckLogicalDecodingRequirements(false); Assert(!MyReplicationSlot); diff --git a/src/include/replication/logical.h b/src/include/replication/logical.h index bc9d4ece672..bc075b16741 100644 --- a/src/include/replication/logical.h +++ b/src/include/replication/logical.h @@ -115,11 +115,12 @@ typedef struct LogicalDecodingContext } LogicalDecodingContext; -extern void CheckLogicalDecodingRequirements(void); +extern void CheckLogicalDecodingRequirements(bool repack); extern LogicalDecodingContext *CreateInitDecodingContext(const char *plugin, List *output_plugin_options, bool need_full_snapshot, + bool for_repack, XLogRecPtr restart_lsn, XLogReaderRoutine *xl_routine, LogicalOutputPluginWriterPrepareWrite prepare_write, diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h index c316a01a807..489af7d8d6c 100644 --- a/src/include/replication/slot.h +++ b/src/include/replication/slot.h @@ -378,7 +378,7 @@ extern void ReplicationSlotDropAtPubNode(WalReceiverConn *wrconn, char *slotname extern void StartupReplicationSlots(void); extern void CheckPointReplicationSlots(bool is_shutdown); -extern void CheckSlotRequirements(void); +extern void CheckSlotRequirements(bool repack); extern void CheckSlotPermissions(void); extern ReplicationSlotInvalidationCause GetSlotInvalidationCause(const char *cause_name); -- 2.47.3 --r2slln3zpmilwu22-- ^ permalink raw reply [nested|flat] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ 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; 100+ 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] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <[email protected]> 0 siblings, 0 replies; 100+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 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 89695335127..7390fd303f6 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -188,6 +188,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, @@ -2039,13 +2041,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. @@ -2054,9 +2049,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, @@ -2088,6 +2081,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)) { @@ -2203,15 +2199,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; @@ -2313,9 +2300,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 { @@ -2416,9 +2402,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. */ @@ -2428,6 +2413,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). @@ -2445,6 +2460,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 */ @@ -2461,7 +2477,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 @@ -2517,37 +2533,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; @@ -4133,9 +4132,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=v02-0008-Make-REPACK-CONCURRENTLY-MVCC-safe.patch ^ permalink raw reply [nested|flat] 100+ messages in thread
end of thread, other threads:[~2026-07-15 08:37 UTC | newest] Thread overview: 100+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2026-04-03 19:01 [PATCH v51 10/10] CheckLogicalDecodingRequirements: be specific about which GUC is limiting Álvaro Herrera <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <[email protected]>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox