agora inbox for [email protected]help / color / mirror / Atom feed
[PATCH v43 1/7] Refactor index_concurrently_create_copy() for use with REPACK (CONCURRENTLY). 94+ messages / 1 participants [nested] [flat]
* [PATCH v43 1/7] Refactor index_concurrently_create_copy() for use with REPACK (CONCURRENTLY). @ 2026-03-11 13:15 Antonin Houska <[email protected]> 0 siblings, 0 replies; 94+ messages in thread From: Antonin Houska @ 2026-03-11 13:15 UTC (permalink / raw) This patch moves the code to index_create_copy() and adds a "concurrently" parameter so it can be used by REPACK (CONCURRENTLY). With the CONCURRENTLY option, REPACK cannot simply swap the heap file and rebuild its indexes. Instead, it needs to build a separate set of indexes (including system catalog entries) *before* the actual swap, to reduce the time AccessExclusiveLock needs to be held for. --- src/backend/catalog/index.c | 54 +++++++++++++++++++++++--------- src/backend/commands/indexcmds.c | 6 ++-- src/backend/nodes/makefuncs.c | 9 +++--- src/include/catalog/index.h | 3 ++ src/include/nodes/makefuncs.h | 4 ++- 5 files changed, 54 insertions(+), 22 deletions(-) diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c index d8219b18c48..98d38dc5229 100644 --- a/src/backend/catalog/index.c +++ b/src/backend/catalog/index.c @@ -1291,15 +1291,32 @@ index_create(Relation heapRelation, /* * index_concurrently_create_copy * - * Create concurrently an index based on the definition of the one provided by - * caller. The index is inserted into catalogs and needs to be built later - * on. This is called during concurrent reindex processing. - * - * "tablespaceOid" is the tablespace to use for this index. + * Variant of index_create_copy(), called during concurrent reindex + * processing. */ Oid index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, Oid tablespaceOid, const char *newName) +{ + return index_create_copy(heapRelation, oldIndexId, tablespaceOid, newName, + true); +} + +/* + * index_create_copy + * + * Create an index based on the definition of the one provided by caller. The + * index is inserted into catalogs. If 'concurrently' is TRUE, it needs to be + * built later on, otherwise it's built immediately. + * + * "tablespaceOid" is the tablespace to use for this index. + * + * The actual implementation of index_concurrently_create_copy(), reusable for + * other purposes. + */ +Oid +index_create_copy(Relation heapRelation, Oid oldIndexId, Oid tablespaceOid, + const char *newName, bool concurrently) { Relation indexRelation; IndexInfo *oldInfo, @@ -1318,6 +1335,7 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, List *indexColNames = NIL; List *indexExprs = NIL; List *indexPreds = NIL; + int flags = 0; indexRelation = index_open(oldIndexId, RowExclusiveLock); @@ -1328,7 +1346,7 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, * Concurrent build of an index with exclusion constraints is not * supported. */ - if (oldInfo->ii_ExclusionOps != NULL) + if (oldInfo->ii_ExclusionOps != NULL && concurrently) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("concurrent index creation for exclusion constraints is not supported"))); @@ -1384,9 +1402,7 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, } /* - * Build the index information for the new index. Note that rebuild of - * indexes with exclusion constraints is not supported, hence there is no - * need to fill all the ii_Exclusion* fields. + * Build the index information for the new index. */ newInfo = makeIndexInfo(oldInfo->ii_NumIndexAttrs, oldInfo->ii_NumIndexKeyAttrs, @@ -1395,10 +1411,13 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, indexPreds, oldInfo->ii_Unique, oldInfo->ii_NullsNotDistinct, - false, /* not ready for inserts */ - true, + !concurrently, /* isready */ + concurrently, /* concurrent */ indexRelation->rd_indam->amsummarizing, - oldInfo->ii_WithoutOverlaps); + oldInfo->ii_WithoutOverlaps, + oldInfo->ii_ExclusionOps, + oldInfo->ii_ExclusionProcs, + oldInfo->ii_ExclusionStrats); /* * Extract the list of column names and the column numbers for the new @@ -1436,6 +1455,9 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, stattargets[i].isnull = isnull; } + if (concurrently) + flags = INDEX_CREATE_SKIP_BUILD | INDEX_CREATE_CONCURRENT; + /* * Now create the new index. * @@ -1459,7 +1481,7 @@ index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, indcoloptions->values, stattargets, reloptionsDatum, - INDEX_CREATE_SKIP_BUILD | INDEX_CREATE_CONCURRENT, + flags, 0, true, /* allow table to be a system catalog? */ false, /* is_internal? */ @@ -2453,7 +2475,8 @@ BuildIndexInfo(Relation index) indexStruct->indisready, false, index->rd_indam->amsummarizing, - indexStruct->indisexclusion && indexStruct->indisunique); + indexStruct->indisexclusion && indexStruct->indisunique, + NULL, NULL, NULL); /* fill in attribute numbers */ for (i = 0; i < numAtts; i++) @@ -2513,7 +2536,8 @@ BuildDummyIndexInfo(Relation index) indexStruct->indisready, false, index->rd_indam->amsummarizing, - indexStruct->indisexclusion && indexStruct->indisunique); + indexStruct->indisexclusion && indexStruct->indisunique, + NULL, NULL, NULL); /* fill in attribute numbers */ for (i = 0; i < numAtts; i++) diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c index b89c6855364..836eedb8ed5 100644 --- a/src/backend/commands/indexcmds.c +++ b/src/backend/commands/indexcmds.c @@ -244,7 +244,8 @@ CheckIndexCompatible(Oid oldId, */ indexInfo = makeIndexInfo(numberOfAttributes, numberOfAttributes, accessMethodId, NIL, NIL, false, false, - false, false, amsummarizing, isWithoutOverlaps); + false, false, amsummarizing, isWithoutOverlaps, + NULL, NULL, NULL); typeIds = palloc_array(Oid, numberOfAttributes); collationIds = palloc_array(Oid, numberOfAttributes); opclassIds = palloc_array(Oid, numberOfAttributes); @@ -931,7 +932,8 @@ DefineIndex(ParseState *pstate, !concurrent, concurrent, amissummarizing, - stmt->iswithoutoverlaps); + stmt->iswithoutoverlaps, + NULL, NULL, NULL); typeIds = palloc_array(Oid, numberOfAttributes); collationIds = palloc_array(Oid, numberOfAttributes); diff --git a/src/backend/nodes/makefuncs.c b/src/backend/nodes/makefuncs.c index 3cd35c5c457..8d23aa917e5 100644 --- a/src/backend/nodes/makefuncs.c +++ b/src/backend/nodes/makefuncs.c @@ -834,7 +834,8 @@ IndexInfo * makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid, List *expressions, List *predicates, bool unique, bool nulls_not_distinct, bool isready, bool concurrent, bool summarizing, - bool withoutoverlaps) + bool withoutoverlaps, Oid *exclusion_ops, Oid *exclusion_procs, + uint16 *exclusion_strats) { IndexInfo *n = makeNode(IndexInfo); @@ -863,9 +864,9 @@ makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid, List *expressions, n->ii_PredicateState = NULL; /* exclusion constraints */ - n->ii_ExclusionOps = NULL; - n->ii_ExclusionProcs = NULL; - n->ii_ExclusionStrats = NULL; + n->ii_ExclusionOps = exclusion_ops; + n->ii_ExclusionProcs = exclusion_procs; + n->ii_ExclusionStrats = exclusion_strats; /* speculative inserts */ n->ii_UniqueOps = NULL; diff --git a/src/include/catalog/index.h b/src/include/catalog/index.h index 36b70689254..144e241ebd3 100644 --- a/src/include/catalog/index.h +++ b/src/include/catalog/index.h @@ -105,6 +105,9 @@ extern Oid index_concurrently_create_copy(Relation heapRelation, Oid oldIndexId, Oid tablespaceOid, const char *newName); +extern Oid index_create_copy(Relation heapRelation, Oid oldIndexId, + Oid tablespaceOid, const char *newName, + bool concurrently); extern void index_concurrently_build(Oid heapRelationId, Oid indexRelationId); diff --git a/src/include/nodes/makefuncs.h b/src/include/nodes/makefuncs.h index bf54d39feb0..40ec249a7a1 100644 --- a/src/include/nodes/makefuncs.h +++ b/src/include/nodes/makefuncs.h @@ -99,7 +99,9 @@ extern IndexInfo *makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid, List *expressions, List *predicates, bool unique, bool nulls_not_distinct, bool isready, bool concurrent, - bool summarizing, bool withoutoverlaps); + bool summarizing, bool withoutoverlaps, + Oid *exclusion_ops, Oid *exclusion_procs, + uint16 *exclusion_strats); extern Node *makeStringConst(char *str, int location); extern DefElem *makeDefElem(char *name, Node *arg, int location); -- 2.47.3 --nzintiedl6o4kcyp Content-Type: text/x-diff; charset=utf-8 Content-Disposition: attachment; filename="v43-0002-Do-not-dereference-varattrib_4b-in-VARSIZE_4B.patch" ^ permalink raw reply [nested|flat] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ 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; 94+ 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] 94+ messages in thread
end of thread, other threads:[~2026-07-15 08:37 UTC | newest] Thread overview: 94+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2026-03-11 13:15 [PATCH v43 1/7] Refactor index_concurrently_create_copy() for use with REPACK (CONCURRENTLY). 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]>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox