agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH v1 5/7] Row pattern recognition patch (docs). 604+ messages / 2 participants [nested] [flat]
* [PATCH v1 5/7] Row pattern recognition patch (docs). @ 2023-06-25 11:48 Tatsuo Ishii <ishii@postgresql.org> 0 siblings, 0 replies; 604+ messages in thread From: Tatsuo Ishii @ 2023-06-25 11:48 UTC (permalink / raw) --- doc/src/sgml/advanced.sgml | 51 ++++++++++++++++++++++++++ doc/src/sgml/func.sgml | 69 ++++++++++++++++++++++++++++++++++++ doc/src/sgml/ref/select.sgml | 18 ++++++++-- 3 files changed, 136 insertions(+), 2 deletions(-) diff --git a/doc/src/sgml/advanced.sgml b/doc/src/sgml/advanced.sgml index 755c9f1485..23ee285b40 100644 --- a/doc/src/sgml/advanced.sgml +++ b/doc/src/sgml/advanced.sgml @@ -537,6 +537,57 @@ WHERE pos < 3; <literal>rank</literal> less than 3. </para> + <para> + Window function <function>rpr</function> can be used with row pattern + common syntax to perform row pattern recognition in a query. Row pattern + common syntax includes two sub clauses. <literal>DEFINE</literal> defines + definition variables along with an expression. The expression must be a + logical expression, which means it must + return <literal>TRUE</literal>, <literal>FALSE</literal> + or <literal>NULL</literal>. Moreover if the expression comprises a column + reference, it must be the argument of <function>rpr</function>. An + example of <literal>DEFINE</literal> is as follows. + +<programlisting> +DEFINE + LOWPRICE AS price <= 100, + UP AS price > PREV(price), + DOWN AS price < PREV(price) +</programlisting> + + Note that <function>PREV</function> returns price column in the previous + row if it's called in a context of row pattern recognition. So in the + second line means the definition variable "UP" is <literal>TRUE</literal> + when price column in the current row is greater than the price column in + the previous row. Likewise, "DOWN" is <literal>TRUE</literal> when when + price column in the current row is lower than the price column in the + previous row. + </para> + <para> + Once <literal>DEFINE</literal> exists, <literal>PATTERN</literal> can be + used. <literal>PATTERN</literal> defines a sequence of rows that satisfies + certain conditions. For example following <literal>PATTERN</literal> + defines that a row starts with the condition "LOWPRICE", then one or more + rows satisfy "UP" and finally one or more rows satisfy "DOWN". If a + sequence of rows found, rpr returns the column at the starting row. + Example of a <literal>SELECT</literal> using the <literal>DEFINE</literal> + and <literal>PATTERN</literal> clause is as follows. + +<programlisting> +SELECT company, tdate, price, rpr(price) OVER w FROM stock + WINDOW w AS ( + PARTITION BY company + ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING + INITIAL + PATTERN (LOWPRICE UP+ DOWN+) + DEFINE + LOWPRICE AS price <= 100, + UP AS price > PREV(price), + DOWN AS price < PREV(price) +); +</programlisting> + </para> + <para> When a query involves multiple window functions, it is possible to write out each one with a separate <literal>OVER</literal> clause, but this is diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml index 5a47ce4343..8069c58ca5 100644 --- a/doc/src/sgml/func.sgml +++ b/doc/src/sgml/func.sgml @@ -21648,6 +21648,22 @@ SELECT count(*) FROM sometable; returns <literal>NULL</literal> if there is no such row. </para></entry> </row> + + <row> + <entry role="func_table_entry"><para role="func_signature"> + <indexterm> + <primary>rpr</primary> + </indexterm> + <function>rpr</function> ( <parameter>value</parameter> <type>anyelement</type> ) + <returnvalue>anyelement</returnvalue> + </para> + <para> + Perform row pattern recognition using column specified + by <parameter>value</parameter> and returns the value of the column if + current row is the first matching row; + returns <literal>NULL</literal> otherwise. + </para></entry> + </row> </tbody> </tgroup> </table> @@ -21687,6 +21703,59 @@ SELECT count(*) FROM sometable; Other frame specifications can be used to obtain other effects. </para> + <para> + Row pattern recognition navigation functions are listed in + <xref linkend="functions-rpr-navigation-table"/>. These functions + can be used to describe DEFINE clause of Row pattern recognition. + </para> + + <table id="functions-rpr-navigation-table"> + <title>Row Pattern Navigation Functions</title> + <tgroup cols="1"> + <thead> + <row> + <entry role="func_table_entry"><para role="func_signature"> + Function + </para> + <para> + Description + </para></entry> + </row> + </thead> + + <tbody> + <row> + <entry role="func_table_entry"><para role="func_signature"> + <indexterm> + <primary>prev</primary> + </indexterm> + <function>prev</function> ( <parameter>value</parameter> <type>anyelement</type> ) + <returnvalue>anyelement</returnvalue> + </para> + <para> + Returns the column value at the previous row; + returns NULL if there is no previous row in the window frame. + </para></entry> + </row> + + <row> + <entry role="func_table_entry"><para role="func_signature"> + <indexterm> + <primary>next</primary> + </indexterm> + <function>next</function> ( <parameter>value</parameter> <type>anyelement</type> ) + <returnvalue>anyelement</returnvalue> + </para> + <para> + Returns the column value at the next row; + returns NULL if there is no next row in the window frame. + </para></entry> + </row> + + </tbody> + </tgroup> + </table> + <note> <para> The SQL standard defines a <literal>RESPECT NULLS</literal> or diff --git a/doc/src/sgml/ref/select.sgml b/doc/src/sgml/ref/select.sgml index 0ee0cc7e64..c0fc16d773 100644 --- a/doc/src/sgml/ref/select.sgml +++ b/doc/src/sgml/ref/select.sgml @@ -966,8 +966,8 @@ WINDOW <replaceable class="parameter">window_name</replaceable> AS ( <replaceabl The <replaceable class="parameter">frame_clause</replaceable> can be one of <synopsis> -{ RANGE | ROWS | GROUPS } <replaceable>frame_start</replaceable> [ <replaceable>frame_exclusion</replaceable> ] -{ RANGE | ROWS | GROUPS } BETWEEN <replaceable>frame_start</replaceable> AND <replaceable>frame_end</replaceable> [ <replaceable>frame_exclusion</replaceable> ] +{ RANGE | ROWS | GROUPS } <replaceable>frame_start</replaceable> [ <replaceable>frame_exclusion</replaceable> ] [row_pattern_common_syntax] +{ RANGE | ROWS | GROUPS } BETWEEN <replaceable>frame_start</replaceable> AND <replaceable>frame_end</replaceable> [ <replaceable>frame_exclusion</replaceable> ] [row_pattern_common_syntax] </synopsis> where <replaceable>frame_start</replaceable> @@ -1074,6 +1074,20 @@ EXCLUDE NO OTHERS a given peer group will be in the frame or excluded from it. </para> + <para> + The + optional <replaceable class="parameter">row_pattern_common_syntax</replaceable> + defines the <firstterm>row pattern recognition condition</firstterm> for + this + window. <replaceable class="parameter">row_pattern_common_syntax</replaceable> + includes following subclauses. + +<synopsis> +PATTERN <replaceable class="parameter">pattern_variable_name</replaceable>[+] [, ...] +DEFINE <replaceable class="parameter">definition_varible_name</replaceable> AS <replaceable class="parameter">expression</replaceable> [, ...] +</synopsis> + </para> + <para> The purpose of a <literal>WINDOW</literal> clause is to specify the behavior of <firstterm>window functions</firstterm> appearing in the query's -- 2.25.1 ----Next_Part(Sun_Jun_25_21_05_09_2023_126)-- Content-Type: Text/X-Patch; charset=us-ascii Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="v1-0006-Row-pattern-recognition-patch-tests.patch" ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
* [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ 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] 604+ messages in thread
end of thread, other threads:[~2026-07-15 08:37 UTC | newest] Thread overview: 604+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2023-06-25 11:48 [PATCH v1 5/7] Row pattern recognition patch (docs). Tatsuo Ishii <ishii@postgresql.org> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 7/8] Decouple updating of freezing information from swap_relation_files(). Antonin Houska <ah@cybertec.at>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox