Rename various "freeze multixact" variables

It seems to make more sense to use "cutoff multixact" terminology
throughout the backend code; "freeze" is associated with replacing of an
Xid with FrozenTransactionId, which is not what we do for MultiXactIds.

Andres Freund
Some adjustments by Álvaro Herrera

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index b1a5d9f65ac055e0c2dd9807ad8477b70a70f3c6..ead3d690aea7db7579f488c09a53cadd75c9df4f 100644 (file)
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -5135,8 +5135,8 @@ heap_freeze_tuple(HeapTupleHeader tuple, TransactionId cutoff_xid,
 
        /*
         * Note that this code handles IS_MULTI Xmax values, too, but only to mark
-        * the tuple frozen if the updating Xid in the mxact is below the freeze
-        * cutoff; it doesn't remove dead members of a very old multixact.
+        * the tuple as not updated if the multixact is below the cutoff Multixact
+        * given; it doesn't remove dead members of a very old multixact.
         */
        xid = HeapTupleHeaderGetRawXmax(tuple);
        if ((tuple->t_infomask & HEAP_XMAX_IS_MULTI) ?

diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
index 7105f0ab651af1b6ed7722cce70257d9a9a2b5a9..951894ce5ac2fc0f069ef4d2b83dc31507c2262c 100644 (file)
--- a/src/backend/access/heap/rewriteheap.c
+++ b/src/backend/access/heap/rewriteheap.c
@@ -129,8 +129,8 @@ typedef struct RewriteStateData
                                                                                 * determine tuple visibility */
        TransactionId rs_freeze_xid;/* Xid that will be used as freeze cutoff
                                                                 * point */
-       MultiXactId rs_freeze_multi;/* MultiXactId that will be used as freeze
-                                                                * cutoff point for multixacts */
+       MultiXactId rs_cutoff_multi;/* MultiXactId that will be used as cutoff
+                                                                * point for multixacts */
        MemoryContext rs_cxt;           /* for hash tables and entries and tuples in
                                                                 * them */
        HTAB       *rs_unresolved_tups;         /* unmatched A tuples */
@@ -180,7 +180,7 @@ static void raw_heap_insert(RewriteState state, HeapTuple tup);
  * new_heap            new, locked heap relation to insert tuples to
  * oldest_xmin xid used by the caller to determine which tuples are dead
  * freeze_xid  xid before which tuples will be frozen
- * freeze_multi multixact before which multis will be frozen
+ * min_multi   multixact before which multis will be removed
  * use_wal             should the inserts to the new heap be WAL-logged?
  *
  * Returns an opaque RewriteState, allocated in current memory context,
@@ -188,7 +188,7 @@ static void raw_heap_insert(RewriteState state, HeapTuple tup);
  */
 RewriteState
 begin_heap_rewrite(Relation new_heap, TransactionId oldest_xmin,
-                                  TransactionId freeze_xid, MultiXactId freeze_multi,
+                                  TransactionId freeze_xid, MultiXactId cutoff_multi,
                                   bool use_wal)
 {
        RewriteState state;
@@ -218,7 +218,7 @@ begin_heap_rewrite(Relation new_heap, TransactionId oldest_xmin,
        state->rs_use_wal = use_wal;
        state->rs_oldest_xmin = oldest_xmin;
        state->rs_freeze_xid = freeze_xid;
-       state->rs_freeze_multi = freeze_multi;
+       state->rs_cutoff_multi = cutoff_multi;
        state->rs_cxt = rw_cxt;
 
        /* Initialize hash tables used to track update chains */
@@ -347,7 +347,7 @@ rewrite_heap_tuple(RewriteState state,
         * very-old xmin or xmax, so that future VACUUM effort can be saved.
         */
        heap_freeze_tuple(new_tuple->t_data, state->rs_freeze_xid,
-                                         state->rs_freeze_multi);
+                                         state->rs_cutoff_multi);
 
        /*
         * Invalid ctid means that ctid should point to the tuple itself. We'll

diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
index 745b1f1d891d070af3a7ff49a63e2f9172f62f1e..e3f5cbc0cd9ca2a20ffe8b1332a249d877aaafcb 100644 (file)
--- a/src/backend/access/transam/multixact.c
+++ b/src/backend/access/transam/multixact.c
@@ -1069,7 +1069,7 @@ GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members,
         * We check known limits on MultiXact before resorting to the SLRU area.
         *
         * An ID older than MultiXactState->oldestMultiXactId cannot possibly be
-        * useful; it should have already been frozen by vacuum.  We've truncated
+        * useful; it should have already been removed by vacuum.  We've truncated
         * the on-disk structures anyway.  Returning the wrong values could lead
         * to an incorrect visibility result.  However, to support pg_upgrade we
         * need to allow an empty set to be returned regardless, if the caller is

diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index 051b806aa72d8111b17e640d16f88f8f96b92583..f6a5bfe8d15b523703ff1242d3d21431841b6592 100644 (file)
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -69,7 +69,7 @@ static void rebuild_relation(Relation OldHeap, Oid indexOid,
 static void copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
                           int freeze_min_age, int freeze_table_age, bool verbose,
                           bool *pSwapToastByContent, TransactionId *pFreezeXid,
-                          MultiXactId *pFreezeMulti);
+                          MultiXactId *pCutoffMulti);
 static List *get_tables_to_cluster(MemoryContext cluster_context);
 static void reform_and_rewrite_tuple(HeapTuple tuple,
                                                 TupleDesc oldTupDesc, TupleDesc newTupDesc,
@@ -566,7 +566,7 @@ rebuild_relation(Relation OldHeap, Oid indexOid,
        bool            is_system_catalog;
        bool            swap_toast_by_content;
        TransactionId frozenXid;
-       MultiXactId frozenMulti;
+       MultiXactId cutoffMulti;
 
        /* Mark the correct index as clustered */
        if (OidIsValid(indexOid))
@@ -585,7 +585,7 @@ rebuild_relation(Relation OldHeap, Oid indexOid,
        /* Copy the heap data into the new table in the desired order */
        copy_heap_data(OIDNewHeap, tableOid, indexOid,
                                   freeze_min_age, freeze_table_age, verbose,
-                                  &swap_toast_by_content, &frozenXid, &frozenMulti);
+                                  &swap_toast_by_content, &frozenXid, &cutoffMulti);
 
        /*
         * Swap the physical files of the target and transient tables, then
@@ -593,7 +593,7 @@ rebuild_relation(Relation OldHeap, Oid indexOid,
         */
        finish_heap_swap(tableOid, OIDNewHeap, is_system_catalog,
                                         swap_toast_by_content, false, true,
-                                        frozenXid, frozenMulti);
+                                        frozenXid, cutoffMulti);
 }
 
 
@@ -736,12 +736,13 @@ make_new_heap(Oid OIDOldHeap, Oid NewTableSpace, bool forcetemp,
  * There are two output parameters:
  * *pSwapToastByContent is set true if toast tables must be swapped by content.
  * *pFreezeXid receives the TransactionId used as freeze cutoff point.
+ * *pCutoffMulti receives the MultiXactId used as a cutoff point.
  */
 static void
 copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
                           int freeze_min_age, int freeze_table_age, bool verbose,
                           bool *pSwapToastByContent, TransactionId *pFreezeXid,
-                          MultiXactId *pFreezeMulti)
+                          MultiXactId *pCutoffMulti)
 {
        Relation        NewHeap,
                                OldHeap,
@@ -757,7 +758,7 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
        bool            is_system_catalog;
        TransactionId OldestXmin;
        TransactionId FreezeXid;
-       MultiXactId MultiXactFrzLimit;
+       MultiXactId MultiXactCutoff;
        RewriteState rwstate;
        bool            use_sort;
        Tuplesortstate *tuplesort;
@@ -858,7 +859,7 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
         */
        vacuum_set_xid_limits(freeze_min_age, freeze_table_age,
                                                  OldHeap->rd_rel->relisshared,
-                                                 &OldestXmin, &FreezeXid, NULL, &MultiXactFrzLimit);
+                                                 &OldestXmin, &FreezeXid, NULL, &MultiXactCutoff);
 
        /*
         * FreezeXid will become the table's new relfrozenxid, and that mustn't go
@@ -869,14 +870,14 @@ copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex,
 
        /* return selected values to caller */
        *pFreezeXid = FreezeXid;
-       *pFreezeMulti = MultiXactFrzLimit;
+       *pCutoffMulti = MultiXactCutoff;
 
        /* Remember if it's a system catalog */
        is_system_catalog = IsSystemRelation(OldHeap);
 
        /* Initialize the rewrite operation */
        rwstate = begin_heap_rewrite(NewHeap, OldestXmin, FreezeXid,
-                                                                MultiXactFrzLimit, use_wal);
+                                                                MultiXactCutoff, use_wal);
 
        /*
         * Decide whether to use an indexscan or seqscan-and-optional-sort to scan
@@ -1135,7 +1136,7 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
                                        bool swap_toast_by_content,
                                        bool is_internal,
                                        TransactionId frozenXid,
-                                       MultiXactId frozenMulti,
+                                       MultiXactId cutoffMulti,
                                        Oid *mapped_tables)
 {
        Relation        relRelation;
@@ -1246,8 +1247,8 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
        {
                Assert(TransactionIdIsNormal(frozenXid));
                relform1->relfrozenxid = frozenXid;
-               Assert(MultiXactIdIsValid(frozenMulti));
-               relform1->relminmxid = frozenMulti;
+               Assert(MultiXactIdIsValid(cutoffMulti));
+               relform1->relminmxid = cutoffMulti;
        }
 
        /* swap size statistics too, since new rel has freshly-updated stats */
@@ -1321,7 +1322,7 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
                                                                        swap_toast_by_content,
                                                                        is_internal,
                                                                        frozenXid,
-                                                                       frozenMulti,
+                                                                       cutoffMulti,
                                                                        mapped_tables);
                        }
                        else
@@ -1464,7 +1465,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
                                 bool check_constraints,
                                 bool is_internal,
                                 TransactionId frozenXid,
-                                MultiXactId frozenMulti)
+                                MultiXactId cutoffMulti)
 {
        ObjectAddress object;
        Oid                     mapped_tables[4];
@@ -1481,7 +1482,7 @@ finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
        swap_relation_files(OIDOldHeap, OIDNewHeap,
                                                (OIDOldHeap == RelationRelationId),
                                                swap_toast_by_content, is_internal,
-                                               frozenXid, frozenMulti, mapped_tables);
+                                               frozenXid, cutoffMulti, mapped_tables);
 
        /*
         * If it's a system catalog, queue an sinval message to flush all

diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c
index a3a150d70084c4a4a9444b51418fa7c4a6e689cd..046ded1494cc4fa7c0637352c4f8389d97004358 100644 (file)
--- a/src/backend/commands/dbcommands.c
+++ b/src/backend/commands/dbcommands.c
@@ -1664,7 +1664,7 @@ get_db_info(const char *name, LOCKMODE lockmode,
                                /* limit of frozen XIDs */
                                if (dbFrozenXidP)
                                        *dbFrozenXidP = dbform->datfrozenxid;
-                               /* limit of frozen Multixacts */
+                               /* minimum MultixactId */
                                if (dbMinMultiP)
                                        *dbMinMultiP = dbform->datminmxid;
                                /* default tablespace for this database */

diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index 2f2c6acb968d598e1aed55972ea86bb773c818de..27aea739e6b5fd9d743d6863c56da1efa2ada689 100644 (file)
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -64,7 +64,7 @@ static BufferAccessStrategy vac_strategy;
 
 /* non-export function prototypes */
 static List *get_rel_oids(Oid relid, const RangeVar *vacrel);
-static void vac_truncate_clog(TransactionId frozenXID, MultiXactId frozenMulti);
+static void vac_truncate_clog(TransactionId frozenXID, MultiXactId minMulti);
 static bool vacuum_rel(Oid relid, VacuumStmt *vacstmt, bool do_toast,
                   bool for_wraparound);
 
@@ -384,7 +384,7 @@ vacuum_set_xid_limits(int freeze_min_age,
                                          TransactionId *oldestXmin,
                                          TransactionId *freezeLimit,
                                          TransactionId *freezeTableLimit,
-                                         MultiXactId *multiXactFrzLimit)
+                                         MultiXactId *multiXactCutoff)
 {
        int                     freezemin;
        TransactionId limit;
@@ -469,7 +469,7 @@ vacuum_set_xid_limits(int freeze_min_age,
                *freezeTableLimit = limit;
        }
 
-       if (multiXactFrzLimit != NULL)
+       if (multiXactCutoff != NULL)
        {
                MultiXactId mxLimit;
 
@@ -481,7 +481,7 @@ vacuum_set_xid_limits(int freeze_min_age,
                if (mxLimit < FirstMultiXactId)
                        mxLimit = FirstMultiXactId;
 
-               *multiXactFrzLimit = mxLimit;
+               *multiXactCutoff = mxLimit;
        }
 }
 
@@ -690,8 +690,8 @@ vac_update_relstats(Relation relation,
  *             Update pg_database's datfrozenxid entry for our database to be the
  *             minimum of the pg_class.relfrozenxid values.
  *
- *             Similarly, update our datfrozenmulti to be the minimum of the
- *             pg_class.relfrozenmulti values.
+ *             Similarly, update our datminmxid to be the minimum of the
+ *             pg_class.relminmxid values.
  *
  *             If we are able to advance either pg_database value, also try to
  *             truncate pg_clog and pg_multixact.
@@ -711,7 +711,7 @@ vac_update_datfrozenxid(void)
        SysScanDesc scan;
        HeapTuple       classTup;
        TransactionId newFrozenXid;
-       MultiXactId newFrozenMulti;
+       MultiXactId newMinMulti;
        bool            dirty = false;
 
        /*
@@ -726,7 +726,7 @@ vac_update_datfrozenxid(void)
         * Similarly, initialize the MultiXact "min" with the value that would be
         * used on pg_class for new tables.  See AddNewRelationTuple().
         */
-       newFrozenMulti = GetOldestMultiXactId();
+       newMinMulti = GetOldestMultiXactId();
 
        /*
         * We must seqscan pg_class to find the minimum Xid, because there is no
@@ -756,8 +756,8 @@ vac_update_datfrozenxid(void)
                if (TransactionIdPrecedes(classForm->relfrozenxid, newFrozenXid))
                        newFrozenXid = classForm->relfrozenxid;
 
-               if (MultiXactIdPrecedes(classForm->relminmxid, newFrozenMulti))
-                       newFrozenMulti = classForm->relminmxid;
+               if (MultiXactIdPrecedes(classForm->relminmxid, newMinMulti))
+                       newMinMulti = classForm->relminmxid;
        }
 
        /* we're done with pg_class */
@@ -765,7 +765,7 @@ vac_update_datfrozenxid(void)
        heap_close(relation, AccessShareLock);
 
        Assert(TransactionIdIsNormal(newFrozenXid));
-       Assert(MultiXactIdIsValid(newFrozenMulti));
+       Assert(MultiXactIdIsValid(newMinMulti));
 
        /* Now fetch the pg_database tuple we need to update. */
        relation = heap_open(DatabaseRelationId, RowExclusiveLock);
@@ -787,9 +787,9 @@ vac_update_datfrozenxid(void)
        }
 
        /* ditto */
-       if (MultiXactIdPrecedes(dbform->datminmxid, newFrozenMulti))
+       if (MultiXactIdPrecedes(dbform->datminmxid, newMinMulti))
        {
-               dbform->datminmxid = newFrozenMulti;
+               dbform->datminmxid = newMinMulti;
                dirty = true;
        }
 
@@ -805,7 +805,7 @@ vac_update_datfrozenxid(void)
         * this action will update that too.
         */
        if (dirty || ForceTransactionIdLimitUpdate())
-               vac_truncate_clog(newFrozenXid, newFrozenMulti);
+               vac_truncate_clog(newFrozenXid, newMinMulti);
 }
 
 
@@ -824,19 +824,19 @@ vac_update_datfrozenxid(void)
  *             info is stale.
  */
 static void
-vac_truncate_clog(TransactionId frozenXID, MultiXactId frozenMulti)
+vac_truncate_clog(TransactionId frozenXID, MultiXactId minMulti)
 {
        TransactionId myXID = GetCurrentTransactionId();
        Relation        relation;
        HeapScanDesc scan;
        HeapTuple       tuple;
        Oid                     oldestxid_datoid;
-       Oid                     oldestmulti_datoid;
+       Oid                     minmulti_datoid;
        bool            frozenAlreadyWrapped = false;
 
        /* init oldest datoids to sync with my frozen values */
        oldestxid_datoid = MyDatabaseId;
-       oldestmulti_datoid = MyDatabaseId;
+       minmulti_datoid = MyDatabaseId;
 
        /*
         * Scan pg_database to compute the minimum datfrozenxid
@@ -869,10 +869,10 @@ vac_truncate_clog(TransactionId frozenXID, MultiXactId frozenMulti)
                        oldestxid_datoid = HeapTupleGetOid(tuple);
                }
 
-               if (MultiXactIdPrecedes(dbform->datminmxid, frozenMulti))
+               if (MultiXactIdPrecedes(dbform->datminmxid, minMulti))
                {
-                       frozenMulti = dbform->datminmxid;
-                       oldestmulti_datoid = HeapTupleGetOid(tuple);
+                       minMulti = dbform->datminmxid;
+                       minmulti_datoid = HeapTupleGetOid(tuple);
                }
        }
 
@@ -896,7 +896,7 @@ vac_truncate_clog(TransactionId frozenXID, MultiXactId frozenMulti)
 
        /* Truncate CLOG and Multi to the oldest computed value */
        TruncateCLOG(frozenXID);
-       TruncateMultiXact(frozenMulti);
+       TruncateMultiXact(minMulti);
 
        /*
         * Update the wrap limit for GetNewTransactionId and creation of new
@@ -905,7 +905,7 @@ vac_truncate_clog(TransactionId frozenXID, MultiXactId frozenMulti)
         * signalling twice?
         */
        SetTransactionIdLimit(frozenXID, oldestxid_datoid);
-       MultiXactAdvanceOldest(frozenMulti, oldestmulti_datoid);
+       MultiXactAdvanceOldest(minMulti, minmulti_datoid);
 }
 
 

diff --git a/src/backend/commands/vacuumlazy.c b/src/backend/commands/vacuumlazy.c
index c34aa53728110149e76bd43c8e4f814fdafa33d7..bb4e03ebcbc5c11c963ae3724724119b84d33506 100644 (file)
--- a/src/backend/commands/vacuumlazy.c
+++ b/src/backend/commands/vacuumlazy.c
@@ -125,7 +125,7 @@ static int  elevel = -1;
 
 static TransactionId OldestXmin;
 static TransactionId FreezeLimit;
-static MultiXactId MultiXactFrzLimit;
+static MultiXactId MultiXactCutoff;
 
 static BufferAccessStrategy vac_strategy;
 
@@ -203,7 +203,7 @@ lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt,
        vacuum_set_xid_limits(vacstmt->freeze_min_age, vacstmt->freeze_table_age,
                                                  onerel->rd_rel->relisshared,
                                                  &OldestXmin, &FreezeLimit, &freezeTableLimit,
-                                                 &MultiXactFrzLimit);
+                                                 &MultiXactCutoff);
        scan_all = TransactionIdPrecedesOrEquals(onerel->rd_rel->relfrozenxid,
                                                                                         freezeTableLimit);
 
@@ -273,7 +273,7 @@ lazy_vacuum_rel(Relation onerel, VacuumStmt *vacstmt,
        if (vacrelstats->scanned_pages < vacrelstats->rel_pages)
                new_frozen_xid = InvalidTransactionId;
 
-       new_min_multi = MultiXactFrzLimit;
+       new_min_multi = MultiXactCutoff;
        if (vacrelstats->scanned_pages < vacrelstats->rel_pages)
                new_min_multi = InvalidMultiXactId;
 
@@ -868,7 +868,7 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
                                 * freezing.  Note we already have exclusive buffer lock.
                                 */
                                if (heap_freeze_tuple(tuple.t_data, FreezeLimit,
-                                                                         MultiXactFrzLimit))
+                                                                         MultiXactCutoff))
                                        frozen[nfrozen++] = offnum;
                        }
                }                                               /* scan along page */
@@ -886,7 +886,7 @@ lazy_scan_heap(Relation onerel, LVRelStats *vacrelstats,
                                XLogRecPtr      recptr;
 
                                recptr = log_heap_freeze(onerel, buf, FreezeLimit,
-                                                                                MultiXactFrzLimit, frozen, nfrozen);
+                                                                                MultiXactCutoff, frozen, nfrozen);
                                PageSetLSN(page, recptr);
                        }
                }
@@ -1231,7 +1231,7 @@ lazy_check_needs_freeze(Buffer buf)
                tupleheader = (HeapTupleHeader) PageGetItem(page, itemid);
 
                if (heap_tuple_needs_freeze(tupleheader, FreezeLimit,
-                                                                       MultiXactFrzLimit, buf))
+                                                                       MultiXactCutoff, buf))
                        return true;
        }                                                       /* scan along page */
 

diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index 5b9f3480a52f091f6e62da444f724bf0372791f7..8c14d0f4e4441446d189b2826fca50f94bd905de 100644 (file)
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -163,7 +163,7 @@ typedef struct avw_dbase
        Oid                     adw_datid;
        char       *adw_name;
        TransactionId adw_frozenxid;
-       MultiXactId adw_frozenmulti;
+       MultiXactId adw_minmulti;
        PgStat_StatDBEntry *adw_entry;
 } avw_dbase;
 
@@ -1176,11 +1176,10 @@ do_start_worker(void)
                }
                else if (for_xid_wrap)
                        continue;                       /* ignore not-at-risk DBs */
-               else if (MultiXactIdPrecedes(tmp->adw_frozenmulti, multiForceLimit))
+               else if (MultiXactIdPrecedes(tmp->adw_minmulti, multiForceLimit))
                {
                        if (avdb == NULL ||
-                               MultiXactIdPrecedes(tmp->adw_frozenmulti,
-                                                                       avdb->adw_frozenmulti))
+                               MultiXactIdPrecedes(tmp->adw_minmulti, avdb->adw_minmulti))
                                avdb = tmp;
                        for_multi_wrap = true;
                        continue;
@@ -1876,7 +1875,7 @@ get_database_list(void)
                avdb->adw_datid = HeapTupleGetOid(tup);
                avdb->adw_name = pstrdup(NameStr(pgdatabase->datname));
                avdb->adw_frozenxid = pgdatabase->datfrozenxid;
-               avdb->adw_frozenmulti = pgdatabase->datminmxid;
+               avdb->adw_minmulti = pgdatabase->datminmxid;
                /* this gets set later: */
                avdb->adw_entry = NULL;
 

diff --git a/src/include/access/rewriteheap.h b/src/include/access/rewriteheap.h
index f82d1f5734737feae6cd68b60d38f54883d6a41d..67cf06620a0d84c76e99f19ed16c9cd9fd47df72 100644 (file)
--- a/src/include/access/rewriteheap.h
+++ b/src/include/access/rewriteheap.h
@@ -21,7 +21,7 @@ typedef struct RewriteStateData *RewriteState;
 
 extern RewriteState begin_heap_rewrite(Relation NewHeap,
                                   TransactionId OldestXmin, TransactionId FreezeXid,
-                                  MultiXactId MultiXactFrzLimit, bool use_wal);
+                                  MultiXactId MultiXactCutoff, bool use_wal);
 extern void end_heap_rewrite(RewriteState state);
 extern void rewrite_heap_tuple(RewriteState state, HeapTuple oldTuple,
                                   HeapTuple newTuple);

diff --git a/src/include/commands/cluster.h b/src/include/commands/cluster.h
index 03d9f176c57189a3428b83584143475105f76be8..a88731832ecf1d04bb9722625ff7ad059ea0e9a2 100644 (file)
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/cluster.h
@@ -33,6 +33,6 @@ extern void finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
                                 bool check_constraints,
                                 bool is_internal,
                                 TransactionId frozenXid,
-                                MultiXactId frozenMulti);
+                                MultiXactId minMulti);
 
 #endif   /* CLUSTER_H */

diff --git a/src/include/commands/vacuum.h b/src/include/commands/vacuum.h
index d8dd8b04ed98caa670531e08efef09afd5bbd371..08bec256ba855d7c105672ce93da0d3b6efb19fb 100644 (file)
--- a/src/include/commands/vacuum.h
+++ b/src/include/commands/vacuum.h
@@ -160,7 +160,7 @@ extern void vacuum_set_xid_limits(int freeze_min_age, int freeze_table_age,
                                          TransactionId *oldestXmin,
                                          TransactionId *freezeLimit,
                                          TransactionId *freezeTableLimit,
-                                         MultiXactId *multiXactFrzLimit);
+                                         MultiXactId *multiXactCutoff);
 extern void vac_update_datfrozenxid(void);
 extern void vacuum_delay_point(void);