Rename (new|old)estCommitTs to (new|old)estCommitTsXid

The variables newestCommitTs and oldestCommitTs sound as if they are
timestamps, but in fact they are the transaction Ids that correspond
to the newest and oldest timestamps rather than the actual timestamps.
Rename these variables to reflect that they are actually xids: to wit
newestCommitTsXid and oldestCommitTsXid respectively. Also modify
related code in a similar fashion, particularly the user facing output
emitted by pg_controldata and pg_resetxlog.

Complaint and patch by me, review by Tom Lane and Alvaro Herrera.
Backpatch to 9.5 where these variables were first introduced.

diff --git a/src/backend/access/rmgrdesc/xlogdesc.c b/src/backend/access/rmgrdesc/xlogdesc.c
index 83cc9e896ebcb9f08fc354e05d28d3edeb844261..5e210b9947dc6c2afb9a41078aa3f9a73114665d 100644 (file)
--- a/src/backend/access/rmgrdesc/xlogdesc.c
+++ b/src/backend/access/rmgrdesc/xlogdesc.c
@@ -59,8 +59,8 @@ xlog_desc(StringInfo buf, XLogReaderState *record)
                                                 checkpoint->oldestXidDB,
                                                 checkpoint->oldestMulti,
                                                 checkpoint->oldestMultiDB,
-                                                checkpoint->oldestCommitTs,
-                                                checkpoint->newestCommitTs,
+                                                checkpoint->oldestCommitTsXid,
+                                                checkpoint->newestCommitTsXid,
                                                 checkpoint->oldestActiveXid,
                                 (info == XLOG_CHECKPOINT_SHUTDOWN) ? "shutdown" : "online");
        }

diff --git a/src/backend/access/transam/commit_ts.c b/src/backend/access/transam/commit_ts.c
index 8f09dc83ae767e0c0848971a84c1630521802e58..9b106dbbd5a29dd2fc58766831d1006a7f8c00a3 100644 (file)
--- a/src/backend/access/transam/commit_ts.c
+++ b/src/backend/access/transam/commit_ts.c
@@ -217,8 +217,8 @@ TransactionTreeSetCommitTsData(TransactionId xid, int nsubxids,
        commitTsShared->dataLastCommit.nodeid = nodeid;
 
        /* and move forwards our endpoint, if needed */
-       if (TransactionIdPrecedes(ShmemVariableCache->newestCommitTs, newestXact))
-               ShmemVariableCache->newestCommitTs = newestXact;
+       if (TransactionIdPrecedes(ShmemVariableCache->newestCommitTsXid, newestXact))
+               ShmemVariableCache->newestCommitTsXid = newestXact;
        LWLockRelease(CommitTsLock);
 }
 
@@ -285,8 +285,8 @@ TransactionIdGetCommitTsData(TransactionId xid, TimestampTz *ts,
        int                     entryno = TransactionIdToCTsEntry(xid);
        int                     slotno;
        CommitTimestampEntry entry;
-       TransactionId oldestCommitTs;
-       TransactionId newestCommitTs;
+       TransactionId oldestCommitTsXid;
+       TransactionId newestCommitTsXid;
 
        /* error if the given Xid doesn't normally commit */
        if (!TransactionIdIsNormal(xid))
@@ -314,18 +314,18 @@ TransactionIdGetCommitTsData(TransactionId xid, TimestampTz *ts,
                return *ts != 0;
        }
 
-       oldestCommitTs = ShmemVariableCache->oldestCommitTs;
-       newestCommitTs = ShmemVariableCache->newestCommitTs;
+       oldestCommitTsXid = ShmemVariableCache->oldestCommitTsXid;
+       newestCommitTsXid = ShmemVariableCache->newestCommitTsXid;
        /* neither is invalid, or both are */
-       Assert(TransactionIdIsValid(oldestCommitTs) == TransactionIdIsValid(newestCommitTs));
+       Assert(TransactionIdIsValid(oldestCommitTsXid) == TransactionIdIsValid(newestCommitTsXid));
        LWLockRelease(CommitTsLock);
 
        /*
         * Return empty if the requested value is outside our valid range.
         */
-       if (!TransactionIdIsValid(oldestCommitTs) ||
-               TransactionIdPrecedes(xid, oldestCommitTs) ||
-               TransactionIdPrecedes(newestCommitTs, xid))
+       if (!TransactionIdIsValid(oldestCommitTsXid) ||
+               TransactionIdPrecedes(xid, oldestCommitTsXid) ||
+               TransactionIdPrecedes(newestCommitTsXid, xid))
        {
                *ts = 0;
                if (nodeid)
@@ -655,14 +655,14 @@ ActivateCommitTs(void)
         * enabled again?  It doesn't look like it does, because there should be a
         * checkpoint that sets the value to InvalidTransactionId at end of
         * recovery; and so any chance of injecting new transactions without
-        * CommitTs values would occur after the oldestCommitTs has been set to
+        * CommitTs values would occur after the oldestCommitTsXid has been set to
         * Invalid temporarily.
         */
        LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
-       if (ShmemVariableCache->oldestCommitTs == InvalidTransactionId)
+       if (ShmemVariableCache->oldestCommitTsXid == InvalidTransactionId)
        {
-               ShmemVariableCache->oldestCommitTs =
-                       ShmemVariableCache->newestCommitTs = ReadNewTransactionId();
+               ShmemVariableCache->oldestCommitTsXid =
+                       ShmemVariableCache->newestCommitTsXid = ReadNewTransactionId();
        }
        LWLockRelease(CommitTsLock);
 
@@ -711,8 +711,8 @@ DeactivateCommitTs(void)
        TIMESTAMP_NOBEGIN(commitTsShared->dataLastCommit.time);
        commitTsShared->dataLastCommit.nodeid = InvalidRepOriginId;
 
-       ShmemVariableCache->oldestCommitTs = InvalidTransactionId;
-       ShmemVariableCache->newestCommitTs = InvalidTransactionId;
+       ShmemVariableCache->oldestCommitTsXid = InvalidTransactionId;
+       ShmemVariableCache->newestCommitTsXid = InvalidTransactionId;
 
        LWLockRelease(CommitTsLock);
 
@@ -832,16 +832,16 @@ SetCommitTsLimit(TransactionId oldestXact, TransactionId newestXact)
         * "future" or signal a disabled committs.
         */
        LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
-       if (ShmemVariableCache->oldestCommitTs != InvalidTransactionId)
+       if (ShmemVariableCache->oldestCommitTsXid != InvalidTransactionId)
        {
-               if (TransactionIdPrecedes(ShmemVariableCache->oldestCommitTs, oldestXact))
-                       ShmemVariableCache->oldestCommitTs = oldestXact;
-               if (TransactionIdPrecedes(newestXact, ShmemVariableCache->newestCommitTs))
-                       ShmemVariableCache->newestCommitTs = newestXact;
+               if (TransactionIdPrecedes(ShmemVariableCache->oldestCommitTsXid, oldestXact))
+                       ShmemVariableCache->oldestCommitTsXid = oldestXact;
+               if (TransactionIdPrecedes(newestXact, ShmemVariableCache->newestCommitTsXid))
+                       ShmemVariableCache->newestCommitTsXid = newestXact;
        }
        else
        {
-               Assert(ShmemVariableCache->newestCommitTs == InvalidTransactionId);
+               Assert(ShmemVariableCache->newestCommitTsXid == InvalidTransactionId);
        }
        LWLockRelease(CommitTsLock);
 }
@@ -850,12 +850,12 @@ SetCommitTsLimit(TransactionId oldestXact, TransactionId newestXact)
  * Move forwards the oldest commitTS value that can be consulted
  */
 void
-AdvanceOldestCommitTs(TransactionId oldestXact)
+AdvanceOldestCommitTsXid(TransactionId oldestXact)
 {
        LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
-       if (ShmemVariableCache->oldestCommitTs != InvalidTransactionId &&
-               TransactionIdPrecedes(ShmemVariableCache->oldestCommitTs, oldestXact))
-               ShmemVariableCache->oldestCommitTs = oldestXact;
+       if (ShmemVariableCache->oldestCommitTsXid != InvalidTransactionId &&
+               TransactionIdPrecedes(ShmemVariableCache->oldestCommitTsXid, oldestXact))
+               ShmemVariableCache->oldestCommitTsXid = oldestXact;
        LWLockRelease(CommitTsLock);
 }
 

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 147fd538d2fc2493edff4d6ed85e8a61361c769b..ce2e0741d3cd08dc20bfc37d23aeed291425673f 100644 (file)
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -4782,8 +4782,8 @@ BootStrapXLOG(void)
        checkPoint.oldestXidDB = TemplateDbOid;
        checkPoint.oldestMulti = FirstMultiXactId;
        checkPoint.oldestMultiDB = TemplateDbOid;
-       checkPoint.oldestCommitTs = InvalidTransactionId;
-       checkPoint.newestCommitTs = InvalidTransactionId;
+       checkPoint.oldestCommitTsXid = InvalidTransactionId;
+       checkPoint.newestCommitTsXid = InvalidTransactionId;
        checkPoint.time = (pg_time_t) time(NULL);
        checkPoint.oldestActiveXid = InvalidTransactionId;
 
@@ -6298,8 +6298,8 @@ StartupXLOG(void)
                                        checkPoint.oldestMulti, checkPoint.oldestMultiDB)));
        ereport(DEBUG1,
                        (errmsg_internal("commit timestamp Xid oldest/newest: %u/%u",
-                                       checkPoint.oldestCommitTs,
-                                       checkPoint.newestCommitTs)));
+                                       checkPoint.oldestCommitTsXid,
+                                       checkPoint.newestCommitTsXid)));
        if (!TransactionIdIsNormal(checkPoint.nextXid))
                ereport(PANIC,
                                (errmsg("invalid next transaction ID")));
@@ -6311,8 +6311,8 @@ StartupXLOG(void)
        MultiXactSetNextMXact(checkPoint.nextMulti, checkPoint.nextMultiOffset);
        SetTransactionIdLimit(checkPoint.oldestXid, checkPoint.oldestXidDB);
        SetMultiXactIdLimit(checkPoint.oldestMulti, checkPoint.oldestMultiDB);
-       SetCommitTsLimit(checkPoint.oldestCommitTs,
-                                        checkPoint.newestCommitTs);
+       SetCommitTsLimit(checkPoint.oldestCommitTsXid,
+                                        checkPoint.newestCommitTsXid);
        XLogCtl->ckptXidEpoch = checkPoint.nextXidEpoch;
        XLogCtl->ckptXid = checkPoint.nextXid;
 
@@ -8330,8 +8330,8 @@ CreateCheckPoint(int flags)
        LWLockRelease(XidGenLock);
 
        LWLockAcquire(CommitTsLock, LW_SHARED);
-       checkPoint.oldestCommitTs = ShmemVariableCache->oldestCommitTs;
-       checkPoint.newestCommitTs = ShmemVariableCache->newestCommitTs;
+       checkPoint.oldestCommitTsXid = ShmemVariableCache->oldestCommitTsXid;
+       checkPoint.newestCommitTsXid = ShmemVariableCache->newestCommitTsXid;
        LWLockRelease(CommitTsLock);
 
        /* Increase XID epoch if we've wrapped around since last checkpoint */

diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index 7c4ef58129e650bd62d20deba0e8df8201f9bdd1..be89b9b86b6003307d92e88cb59bc8e3a0974608 100644 (file)
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -1151,7 +1151,7 @@ vac_truncate_clog(TransactionId frozenXID,
         */
        SetTransactionIdLimit(frozenXID, oldestxid_datoid);
        SetMultiXactIdLimit(minMulti, minmulti_datoid);
-       AdvanceOldestCommitTs(frozenXID);
+       AdvanceOldestCommitTsXid(frozenXID);
 }
 
 

diff --git a/src/bin/pg_controldata/pg_controldata.c b/src/bin/pg_controldata/pg_controldata.c
index 32e1d81bf20fdb5fbbde6b459eadf2221199fa4b..e7e072f7f38dcde54b6dcfa357c6c22c8679c4a5 100644 (file)
--- a/src/bin/pg_controldata/pg_controldata.c
+++ b/src/bin/pg_controldata/pg_controldata.c
@@ -271,10 +271,10 @@ main(int argc, char *argv[])
                   ControlFile.checkPointCopy.oldestMulti);
        printf(_("Latest checkpoint's oldestMulti's DB: %u\n"),
                   ControlFile.checkPointCopy.oldestMultiDB);
-       printf(_("Latest checkpoint's oldestCommitTs:   %u\n"),
-                  ControlFile.checkPointCopy.oldestCommitTs);
-       printf(_("Latest checkpoint's newestCommitTs:   %u\n"),
-                  ControlFile.checkPointCopy.newestCommitTs);
+       printf(_("Latest checkpoint's oldestCommitTsXid:%u\n"),
+                  ControlFile.checkPointCopy.oldestCommitTsXid);
+       printf(_("Latest checkpoint's newestCommitTsXid:%u\n"),
+                  ControlFile.checkPointCopy.newestCommitTsXid);
        printf(_("Time of latest checkpoint:            %s\n"),
                   ckpttime_str);
        printf(_("Fake LSN counter for unlogged rels:   %X/%X\n"),

diff --git a/src/bin/pg_resetxlog/pg_resetxlog.c b/src/bin/pg_resetxlog/pg_resetxlog.c
index d7ac2ba2715dc9771895e69c5780ad55951a8aac..f675c9224bd5bdf3735bab1220c642281f889c49 100644 (file)
--- a/src/bin/pg_resetxlog/pg_resetxlog.c
+++ b/src/bin/pg_resetxlog/pg_resetxlog.c
@@ -64,8 +64,8 @@ static bool guessed = false;  /* T if we had to guess at any values */
 static const char *progname;
 static uint32 set_xid_epoch = (uint32) -1;
 static TransactionId set_xid = 0;
-static TransactionId set_oldest_commit_ts = 0;
-static TransactionId set_newest_commit_ts = 0;
+static TransactionId set_oldest_commit_ts_xid = 0;
+static TransactionId set_newest_commit_ts_xid = 0;
 static Oid     set_oid = 0;
 static MultiXactId set_mxid = 0;
 static MultiXactOffset set_mxoff = (MultiXactOffset) -1;
@@ -164,14 +164,14 @@ main(int argc, char *argv[])
                                break;
 
                        case 'c':
-                               set_oldest_commit_ts = strtoul(optarg, &endptr, 0);
+                               set_oldest_commit_ts_xid = strtoul(optarg, &endptr, 0);
                                if (endptr == optarg || *endptr != ',')
                                {
                                        fprintf(stderr, _("%s: invalid argument for option %s\n"), progname, "-c");
                                        fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
                                        exit(1);
                                }
-                               set_newest_commit_ts = strtoul(endptr + 1, &endptr2, 0);
+                               set_newest_commit_ts_xid = strtoul(endptr + 1, &endptr2, 0);
                                if (endptr2 == endptr + 1 || *endptr2 != '\0')
                                {
                                        fprintf(stderr, _("%s: invalid argument for option %s\n"), progname, "-c");
@@ -179,15 +179,15 @@ main(int argc, char *argv[])
                                        exit(1);
                                }
 
-                               if (set_oldest_commit_ts < 2 &&
-                                       set_oldest_commit_ts != 0)
+                               if (set_oldest_commit_ts_xid < 2 &&
+                                       set_oldest_commit_ts_xid != 0)
                                {
                                        fprintf(stderr, _("%s: transaction ID (-c) must be either 0 or greater than or equal to 2\n"), progname);
                                        exit(1);
                                }
 
-                               if (set_newest_commit_ts < 2 &&
-                                       set_newest_commit_ts != 0)
+                               if (set_newest_commit_ts_xid < 2 &&
+                                       set_newest_commit_ts_xid != 0)
                                {
                                        fprintf(stderr, _("%s: transaction ID (-c) must be either 0 or greater than or equal to 2\n"), progname);
                                        exit(1);
@@ -383,10 +383,10 @@ main(int argc, char *argv[])
                ControlFile.checkPointCopy.oldestXidDB = InvalidOid;
        }
 
-       if (set_oldest_commit_ts != 0)
-               ControlFile.checkPointCopy.oldestCommitTs = set_oldest_commit_ts;
-       if (set_newest_commit_ts != 0)
-               ControlFile.checkPointCopy.newestCommitTs = set_newest_commit_ts;
+       if (set_oldest_commit_ts_xid != 0)
+               ControlFile.checkPointCopy.oldestCommitTsXid = set_oldest_commit_ts_xid;
+       if (set_newest_commit_ts_xid != 0)
+               ControlFile.checkPointCopy.newestCommitTsXid = set_newest_commit_ts_xid;
 
        if (set_oid != 0)
                ControlFile.checkPointCopy.nextOid = set_oid;
@@ -665,10 +665,10 @@ PrintControlValues(bool guessed)
                   ControlFile.checkPointCopy.oldestMulti);
        printf(_("Latest checkpoint's oldestMulti's DB: %u\n"),
                   ControlFile.checkPointCopy.oldestMultiDB);
-       printf(_("Latest checkpoint's oldestCommitTs:   %u\n"),
-                  ControlFile.checkPointCopy.oldestCommitTs);
-       printf(_("Latest checkpoint's newestCommitTs:   %u\n"),
-                  ControlFile.checkPointCopy.newestCommitTs);
+       printf(_("Latest checkpoint's oldestCommitTsXid:%u\n"),
+                  ControlFile.checkPointCopy.oldestCommitTsXid);
+       printf(_("Latest checkpoint's newestCommitTsXid:%u\n"),
+                  ControlFile.checkPointCopy.newestCommitTsXid);
        printf(_("Maximum data alignment:               %u\n"),
                   ControlFile.maxAlign);
        /* we don't print floatFormat since can't say much useful about it */
@@ -751,15 +751,15 @@ PrintNewControlValues(void)
                           ControlFile.checkPointCopy.nextXidEpoch);
        }
 
-       if (set_oldest_commit_ts != 0)
+       if (set_oldest_commit_ts_xid != 0)
        {
-               printf(_("oldestCommitTs:                       %u\n"),
-                          ControlFile.checkPointCopy.oldestCommitTs);
+               printf(_("oldestCommitTsXid:                    %u\n"),
+                          ControlFile.checkPointCopy.oldestCommitTsXid);
        }
-       if (set_newest_commit_ts != 0)
+       if (set_newest_commit_ts_xid != 0)
        {
-               printf(_("newestCommitTs:                       %u\n"),
-                          ControlFile.checkPointCopy.newestCommitTs);
+               printf(_("newestCommitTsXid:                    %u\n"),
+                          ControlFile.checkPointCopy.newestCommitTsXid);
        }
 }
 

diff --git a/src/include/access/commit_ts.h b/src/include/access/commit_ts.h
index 425f25870fd6dedb2c5c0c4a29ebd5e98faeae52..b11715a2b95333f3108bbc70f334cad7a0eca13d 100644 (file)
--- a/src/include/access/commit_ts.h
+++ b/src/include/access/commit_ts.h
@@ -43,7 +43,7 @@ extern void ExtendCommitTs(TransactionId newestXact);
 extern void TruncateCommitTs(TransactionId oldestXact);
 extern void SetCommitTsLimit(TransactionId oldestXact,
                                 TransactionId newestXact);
-extern void AdvanceOldestCommitTs(TransactionId oldestXact);
+extern void AdvanceOldestCommitTsXid(TransactionId oldestXact);
 
 /* XLOG stuff */
 #define COMMIT_TS_ZEROPAGE             0x00

diff --git a/src/include/access/transam.h b/src/include/access/transam.h
index 96b3facb14d78feefd0a9d9c8e4a5e59acffe3c5..9ad5761f81161820dc7e3b1665beb014a97370f9 100644 (file)
--- a/src/include/access/transam.h
+++ b/src/include/access/transam.h
@@ -126,8 +126,8 @@ typedef struct VariableCacheData
        /*
         * These fields are protected by CommitTsLock
         */
-       TransactionId oldestCommitTs;
-       TransactionId newestCommitTs;
+       TransactionId oldestCommitTsXid;
+       TransactionId newestCommitTsXid;
 
        /*
         * These fields are protected by ProcArrayLock.

diff --git a/src/include/catalog/pg_control.h b/src/include/catalog/pg_control.h
index ad1eb4b9ccd8788dc9c05a57610a66e9ea03ac89..0b8bea74a891831bc3cbe8fd4d4233475a8329c4 100644 (file)
--- a/src/include/catalog/pg_control.h
+++ b/src/include/catalog/pg_control.h
@@ -46,9 +46,9 @@ typedef struct CheckPoint
        MultiXactId oldestMulti;        /* cluster-wide minimum datminmxid */
        Oid                     oldestMultiDB;  /* database with minimum datminmxid */
        pg_time_t       time;                   /* time stamp of checkpoint */
-       TransactionId oldestCommitTs;           /* oldest Xid with valid commit
+       TransactionId oldestCommitTsXid;        /* oldest Xid with valid commit
                                                                                 * timestamp */
-       TransactionId newestCommitTs;           /* newest Xid with valid commit
+       TransactionId newestCommitTsXid;        /* newest Xid with valid commit
                                                                                 * timestamp */
 
        /*