本節介紹了PostgreSQL獲取事務號XID的邏輯,主要解析了函式AssignTransactionId->GetNewTransactionId的實現邏輯。

在GetNewTransactionId函式中,檢查是否可以安全的分配XID.
這可以防止由於XID wraparound而導致的災難性資料丟失.
基本規則是:
如果超過了xidVacLimit,開始嘗試強制autovacuum迴圈.
如果超過了xidWarnLimit,開始發出警告.
如果超過了xidStopLimit,拒絕執行事務,直至以單使用者模式執行.
(這為DBA提供了一個逃生通道，使他們能夠透過資料庫早期的安全性檢測,進入資料庫進行維護)

ShmemVariableCache->xidVacLimit  --> 200,000,561    --> 大於等於該值,觸發自動vacuum
ShmemVariableCache->xidWarnLimit --> 2,136,484,208  --> 大於等於該值,系統報警
ShmemVariableCache->xidStopLimit --> 2,146,484,208  --> 大於等於該值,系統不允許執行事務,使用單使用者模式處理

### 一、資料結構
**TransactionState**
事務狀態結構體
```
/*
 *  transaction states - transaction state from server perspective
 *  事務狀態列舉 - 伺服器視角的事務狀態
 */
typedef enum TransState
{
    TRANS_DEFAULT,              /* idle 空閒 */
    TRANS_START,                /* transaction starting 事務啟動 */
    TRANS_INPROGRESS,           /* inside a valid transaction 進行中 */
    TRANS_COMMIT,               /* commit in progress 提交中 */
    TRANS_ABORT,                /* abort in progress 回滾中 */
    TRANS_PREPARE               /* prepare in progress 準備中 */
} TransState;

/*
 *  transaction block states - transaction state of client queries
 *  事務塊狀態 - 客戶端查詢的事務狀態
 *
 * Note: the subtransaction states are used only for non-topmost
 * transactions; the others appear only in the topmost transaction.
 * 注意:subtransaction只用於非頂層事務;其他欄位用於頂層事務.
 */
typedef enum TBlockState
{
    /* not-in-transaction-block states 未進入事務塊狀態 */
    TBLOCK_DEFAULT,             /* idle 空閒  */
    TBLOCK_STARTED,             /* running single-query transaction 單個查詢事務 */

/* transaction block states 事務塊狀態 */
    TBLOCK_BEGIN,               /* starting transaction block 開始事務塊 */
    TBLOCK_INPROGRESS,          /* live transaction 進行中 */
    TBLOCK_IMPLICIT_INPROGRESS, /* live transaction after implicit BEGIN 隱式事務,進行中 */
    TBLOCK_PARALLEL_INPROGRESS, /* live transaction inside parallel worker 並行worker中的事務,進行中 */
    TBLOCK_END,                 /* COMMIT received 接收到COMMIT */
    TBLOCK_ABORT,               /* failed xact, awaiting ROLLBACK 失敗,等待ROLLBACK */
    TBLOCK_ABORT_END,           /* failed xact, ROLLBACK received 失敗,已接收ROLLBACK */
    TBLOCK_ABORT_PENDING,       /* live xact, ROLLBACK received 進行中,接收到ROLLBACK */
    TBLOCK_PREPARE,             /* live xact, PREPARE received 進行中,接收到PREPARE */

/* subtransaction states 子事務狀態 */
    TBLOCK_SUBBEGIN,            /* starting a subtransaction 開啟 */
    TBLOCK_SUBINPROGRESS,       /* live subtransaction 進行中 */
    TBLOCK_SUBRELEASE,          /* RELEASE received 接收到RELEASE */
    TBLOCK_SUBCOMMIT,           /* COMMIT received while TBLOCK_SUBINPROGRESS 進行中,接收到COMMIT */
    TBLOCK_SUBABORT,            /* failed subxact, awaiting ROLLBACK 失敗,等待ROLLBACK */
    TBLOCK_SUBABORT_END,        /* failed subxact, ROLLBACK received 失敗,已接收ROLLBACK */
    TBLOCK_SUBABORT_PENDING,    /* live subxact, ROLLBACK received 進行中,接收到ROLLBACK */
    TBLOCK_SUBRESTART,          /* live subxact, ROLLBACK TO received 進行中,接收到ROLLBACK TO */
    TBLOCK_SUBABORT_RESTART     /* failed subxact, ROLLBACK TO received 失敗,已接收ROLLBACK TO */
} TBlockState;

/*
 *  transaction state structure
 *  事務狀態結構體
 */
typedef struct TransactionStateData
{
    //事務ID
    TransactionId transactionId;    /* my XID, or Invalid if none */
    //子事務ID
    SubTransactionId subTransactionId;  /* my subxact ID */
    //儲存點名稱
    char       *name;           /* savepoint name, if any */
    //儲存點級別
    int         savepointLevel; /* savepoint level */
    //低階別的事務狀態
    TransState  state;          /* low-level state */
    //高階別的事務狀態
    TBlockState blockState;     /* high-level state */
    //事務巢狀深度
    int         nestingLevel;   /* transaction nesting depth */
    //GUC上下文巢狀深度
    int         gucNestLevel;   /* GUC context nesting depth */
    //事務生命週期上下文
    MemoryContext curTransactionContext;    /* my xact-lifetime context */
    //查詢資源
    ResourceOwner curTransactionOwner;  /* my query resources */
    //按XID順序儲存的已提交的子事務ID
    TransactionId *childXids;   /* subcommitted child XIDs, in XID order */
    //childXids陣列大小
    int         nChildXids;     /* # of subcommitted child XIDs */
    //分配的childXids陣列空間
    int         maxChildXids;   /* allocated size of childXids[] */
    //上一個CurrentUserId
    Oid         prevUser;       /* previous CurrentUserId setting */
    //上一個SecurityRestrictionContext
    int         prevSecContext; /* previous SecurityRestrictionContext */
    //上一事務是否只讀?
    bool        prevXactReadOnly;   /* entry-time xact r/o state */
    //是否處於Recovery?
    bool        startedInRecovery;  /* did we start in recovery? */
    //XID是否已儲存在WAL Record中?
    bool        didLogXid;      /* has xid been included in WAL record? */
    //Enter/ExitParallelMode計數器
    int         parallelModeLevel;  /* Enter/ExitParallelMode counter */
    //父事務狀態
    struct TransactionStateData *parent;    /* back link to parent */
} TransactionStateData;

//結構體指標
typedef TransactionStateData *TransactionState;

```

**ShmemVariableCache**
VariableCache是共享記憶體中的一種資料結構，用於跟蹤OID和XID分配狀態。
ShmemVariableCache-->共享記憶體中的指標
```
/*
 * VariableCache is a data structure in shared memory that is used to track
 * OID and XID assignment state.  For largely historical reasons, there is
 * just one struct with different fields that are protected by different
 * LWLocks.
 * VariableCache是共享記憶體中的一種資料結構，用於跟蹤OID和XID分配狀態。
 * 由於歷史原因，這個結構體有不同的欄位,由不同的LWLocks保護。
 *
 * Note: xidWrapLimit and oldestXidDB are not "active" values, but are
 * used just to generate useful messages when xidWarnLimit or xidStopLimit
 * are exceeded.
 * 注意:xidWrapLimit和oldestXidDB是不"活躍"的值,在xidWarnLimit或xidStopLimit
 *   超出限制時用於產生有用的資訊.
 */
typedef struct VariableCacheData
{
    /*
     * These fields are protected by OidGenLock.
     * 這些域欄位透過OidGenLock欄位保護
     */
    //下一個待分配的OID
    Oid         nextOid;        /* next OID to assign */
    //在必須執行XLOG work前可用OIDs
    uint32      oidCount;       /* OIDs available before must do XLOG work */

/*
     * These fields are protected by XidGenLock.
     * 這些欄位透過XidGenLock鎖保護.
     */
    //下一個待分配的事務ID
    TransactionId nextXid;      /* next XID to assign */

//叢集範圍內最小datfrozenxid
    TransactionId oldestXid;    /* cluster-wide minimum datfrozenxid */
    //在該XID開始強制執行autovacuum
    TransactionId xidVacLimit;  /* start forcing autovacuums here */
    //在該XID開始提出警告
    TransactionId xidWarnLimit; /* start complaining here */
    //在該XID開外,拒絕生成下一個XID
    TransactionId xidStopLimit; /* refuse to advance nextXid beyond here */
    //"世界末日"XID,需回捲
    TransactionId xidWrapLimit; /* where the world ends */
    //持有最小datfrozenxid的DB
    Oid         oldestXidDB;    /* database with minimum datfrozenxid */

/*
     * These fields are protected by CommitTsLock
     * 這些欄位透過CommitTsLock鎖保護
     */
    TransactionId oldestCommitTsXid;
    TransactionId newestCommitTsXid;

/*
     * These fields are protected by ProcArrayLock.
     * 這些欄位透過ProcArrayLock鎖保護
     */
    TransactionId latestCompletedXid;   /* newest XID that has committed or
                                         * aborted */

/*
     * These fields are protected by CLogTruncationLock
     * 這些欄位透過CLogTruncationLock鎖保護
     */
    //clog中最古老的XID
    TransactionId oldestClogXid;    /* oldest it's safe to look up in clog */

} VariableCacheData;
//結構體指標
typedef VariableCacheData *VariableCache;

/* pointer to "variable cache" in shared memory (set up by shmem.c) */
//共享記憶體中的指標(透過shmem.c設定)
VariableCache ShmemVariableCache = NULL;

```

### 二、原始碼解讀
AssignTransactionId函式,給定的TransactionState分配一個新的持久化事務號XID,在此函式呼叫前,不會為事務分配XIDs.GetNewTransactionId是獲取事務ID實際執行的地方,該函式從共享記憶體變數ShmemVariableCache中獲取nextXid,+1後作為新的XID.
```
/*
 * Allocate the next XID for a new transaction or subtransaction.
 * 為新事務或新子事務分配XID
 *
 * The new XID is also stored into MyPgXact before returning.
 * 在返回前,XID會儲存在全域性變數MyPgXact中
 *
 * Note: when this is called, we are actually already inside a valid
 * transaction, since XIDs are now not allocated until the transaction
 * does something.  So it is safe to do a database lookup if we want to
 * issue a warning about XID wrap.
 * 注意:在該函式呼叫時,我們實際上已在一個有效的事務中,因為XIDs在事務不做些事情前不會分配.
 * 因此，如果我們想發出關於XID wrap回捲的警告，那麼進行資料庫查詢是安全的。
 */
TransactionId
GetNewTransactionId(bool isSubXact)
{
    TransactionId xid;

/*
     * Workers synchronize transaction state at the beginning of each parallel
     * operation, so we can't account for new XIDs after that point.
     * 在每個並行操作前,Parallel Workers同步事務狀態,
     *   因此我們不能在這時候請求XIDs
     */
    if (IsInParallelMode())
        elog(ERROR, "cannot assign TransactionIds during a parallel operation");

/*
     * During bootstrap initialization, we return the special bootstrap
     * transaction id.
     * 在宇宙初啟時,返回特別的bootstrap事務ID
     */
    if (IsBootstrapProcessingMode())
    {
        Assert(!isSubXact);
        MyPgXact->xid = BootstrapTransactionId;
        return BootstrapTransactionId;//--> 1
    }

/* safety check, we should never get this far in a HS standby */
    * 安全檢查
    if (RecoveryInProgress())
        elog(ERROR, "cannot assign TransactionIds during recovery");

LWLockAcquire(XidGenLock, LW_EXCLUSIVE);

//從共享記憶體中獲取下一個XID
    xid = ShmemVariableCache->nextXid;

/*----------
     * Check to see if it's safe to assign another XID.  This protects against
     * catastrophic data loss due to XID wraparound.  The basic rules are:
     * 檢查是否可以安全的分配另外一個XID.
     * 這可以防止由於XID wraparound而導致的災難性資料丟失.
     * 基本規則是:
     *
     * If we're past xidVacLimit, start trying to force autovacuum cycles.
     * If we're past xidWarnLimit, start issuing warnings.
     * If we're past xidStopLimit, refuse to execute transactions, unless
     * we are running in single-user mode (which gives an escape hatch
     * to the DBA who somehow got past the earlier defenses).
     * 如果超過了xidVacLimit,開始嘗試強制autovacuum迴圈.
     * 如果超過了xidWarnLimit,開始發出警告.
     * 如果超過了xidStopLimit,拒絕執行事務,直至以單使用者模式執行.
     * (這為DBA提供了一個逃生通道，使他們能夠透過資料庫早期的安全性檢測)
     *
     * Note that this coding also appears in GetNewMultiXactId.
     * 注意這部分程式碼在GetNewMultiXactId中也會出現.
     *----------
     */
    //TransactionIdFollowsOrEquals --> is id1 logically >= id2?
    if (TransactionIdFollowsOrEquals(xid, ShmemVariableCache->xidVacLimit))
    {
        //xid >= ShmemVariableCache->xidVacLimit
        /*
         * For safety's sake, we release XidGenLock while sending signals,
         * warnings, etc.  This is not so much because we care about
         * preserving concurrency in this situation, as to avoid any
         * possibility of deadlock while doing get_database_name(). First,
         * copy all the shared values we'll need in this path.
         * 為了安全起見，我們在傳送訊號、警告等時釋放XidGenLock。
         * 這並不是因為我們關心在這種情況下併發性，
         *   而是因為在執行get_database_name()時要避免出現死鎖
         */
        //獲取相關XID
        TransactionId xidWarnLimit = ShmemVariableCache->xidWarnLimit;
        TransactionId xidStopLimit = ShmemVariableCache->xidStopLimit;
        TransactionId xidWrapLimit = ShmemVariableCache->xidWrapLimit;
        Oid         oldest_datoid = ShmemVariableCache->oldestXidDB;

LWLockRelease(XidGenLock);

/*
         * To avoid swamping the postmaster with signals, we issue the autovac
         * request only once per 64K transaction starts.  This still gives
         * plenty of chances before we get into real trouble.
         * 為了避免訊號淹沒postmaster，我們每64K事務開始時只發出一次autovac請求。
         * 在我們陷入真正的麻煩之前，這仍然給了我們很多解決問題的機會。
         */
        if (IsUnderPostmaster && (xid % 65536) == 0)
            //每隔64K發一次
            SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);

if (IsUnderPostmaster &&
            TransactionIdFollowsOrEquals(xid, xidStopLimit))
        {
            //xid >= ShmemVariableCache->xidStopLimit
            char       *oldest_datname = get_database_name(oldest_datoid);

/* complain even if that DB has disappeared */
            //就算DB已消失,也要不停的警告:(
            if (oldest_datname)
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("database is not accepting commands to avoid wraparound data loss in database \"%s\"",
                                oldest_datname),
                         errhint("Stop the postmaster and vacuum that database in single-user mode.\n"
                                 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                         errmsg("database is not accepting commands to avoid wraparound data loss in database with OID %u",
                                oldest_datoid),
                         errhint("Stop the postmaster and vacuum that database in single-user mode.\n"
                                 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
        }
        else if (TransactionIdFollowsOrEquals(xid, xidWarnLimit))
        {
            ////xid >= ShmemVariableCache->xidWarnLimit
            char       *oldest_datname = get_database_name(oldest_datoid);

/* complain even if that DB has disappeared */
            if (oldest_datname)
                ereport(WARNING,
                        (errmsg("database \"%s\" must be vacuumed within %u transactions",
                                oldest_datname,
                                xidWrapLimit - xid),
                         errhint("To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
                                 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
            else
                ereport(WARNING,
                        (errmsg("database with OID %u must be vacuumed within %u transactions",
                                oldest_datoid,
                                xidWrapLimit - xid),
                         errhint("To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
                                 "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
        }

/* Re-acquire lock and start over */
        //重新獲取鎖並啟動
        LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
        xid = ShmemVariableCache->nextXid;
    }

/*
     * If we are allocating the first XID of a new page of the commit log,
     * zero out that commit-log page before returning. We must do this while
     * holding XidGenLock, else another xact could acquire and commit a later
     * XID before we zero the page.  Fortunately, a page of the commit log
     * holds 32K or more transactions, so we don't have to do this very often.
     * 如果在clog的新page中分配第一個XID,返回前初始化clog page.
     * 必須在持有XidGenLock鎖時執行這個操作,否則的話,
     *   其他事務可能會請求該鎖並在初始化page前提交了一個新事務.
     * 幸運的是，提交日誌的一個頁面包含32K或更多的事務，所以我們不需要經常這樣做。
     *
     * Extend pg_subtrans and pg_commit_ts too.
     * 同時擴充套件pg_subtrans和pg_commit_ts
     */
    ExtendCLOG(xid);
    ExtendCommitTs(xid);
    ExtendSUBTRANS(xid);

/*
     * Now advance the nextXid counter.  This must not happen until after we
     * have successfully completed ExtendCLOG() --- if that routine fails, we
     * want the next incoming transaction to try it again.  We cannot assign
     * more XIDs until there is CLOG space for them.
     * 現在可以更新nextXid計數器了.
     * 這必須在我們成功完成ExtendCLOG()之後才能執行——如果該例程失敗，
     *   我們希望下一個進入的事務再次嘗試。
     * 不能分配更多的xid，除非有空閒的CLOG空間。
     */
    //ShmemVariableCache->nextXid ++
    //if ((ShmemVariableCache->nextXid) < FirstNormalTransactionId) 
    //   (ShmemVariableCache->nextXid) = FirstNormalTransactionId; 
    TransactionIdAdvance(ShmemVariableCache->nextXid);

/*
     * We must store the new XID into the shared ProcArray before releasing
     * XidGenLock.  This ensures that every active XID older than
     * latestCompletedXid is present in the ProcArray, which is essential for
     * correct OldestXmin tracking; see src/backend/access/transam/README.
     * 在釋放XidGenLock前,儲存新的XID到共享資料結構ProcArray中.
     * 這可以確保每一個活動的比latestCompletedXid舊的XID都會出現在ProcArray中,
     *   這樣可以減少OldestXmin的跟蹤,請檢視src/backend/access/transam/README.
     * 
     * Note that readers of PGXACT xid fields should be careful to fetch the
     * value only once, rather than assume they can read a value multiple
     * times and get the same answer each time.  Note we are assuming that
     * TransactionId and int fetch/store are atomic.
     * 要注意的是讀取PGXACT.xid欄位時小心只提取一次,
     *   而不是假定可以多次讀取該值而認為每次返回的值都一樣.
     * 同時我們假定TransactionId和int 提取/寫入是原子的.
     * 
     * The same comments apply to the subxact xid count and overflow fields.
     * 對於subxact xid計數器和溢位欄位,參見上述註釋.
     *
     * Use of a write barrier prevents dangerous code rearrangement in this
     * function; other backends could otherwise e.g. be examining my subxids
     * info concurrently, and we don't want them to see an invalid
     * intermediate state, such as an incremented nxids before the array entry
     * is filled.
     * 在該函式中,進入堡壘進行寫可以防止危險的事情出現.
     * 否則其他後臺程式可能會比如同步檢查本程式的subxids資訊,但我們不希望它們看到無效的中間狀態,
     *   例如，在陣列條目被填充之前增加nxid。
     *
     * Other processes that read nxids should do so before reading xids
     * elements with a pg_read_barrier() in between, so that they can be sure
     * not to read an uninitialized array element; see
     * src/backend/storage/lmgr/README.barrier.
     * 其他讀取nxids的程式應在使用pg_read_barrier()函式讀取xids條目前執行相關操作,
     *   這樣可以確保它們不會讀取到未經初始化的陣列條目,檢視src/backend/storage/lmgr/README.barrier說明.
     *
     * If there's no room to fit a subtransaction XID into PGPROC, set the
     * cache-overflowed flag instead.  This forces readers to look in
     * pg_subtrans to map subtransaction XIDs up to top-level XIDs. There is a
     * race-condition window, in that the new XID will not appear as running
     * until its parent link has been placed into pg_subtrans. However, that
     * will happen before anyone could possibly have a reason to inquire about
     * the status of the XID, so it seems OK.  (Snapshots taken during this
     * window *will* include the parent XID, so they will deliver the correct
     * answer later on when someone does have a reason to inquire.)
     * 如果沒有空間將子事務XID放入PGPROC中，則設定cache-overflow標誌。
     * 這可以強制readers檢視pg_subtrans以將子事務xid對映到頂層xid。
     * 有一個race-condition視窗，在它的父連結被放入pg_subtrans之前，新的XID不會顯示為正在執行.
     * 然而，在都有可能有理由查詢XID的狀態之前，這種情況就會發生，所以看起來是可以的。
     * (在這個視窗中拍攝的快照*將*包含父XID，因此當稍後有程式查詢時，它們將提供正確的答案。)
     */
    if (!isSubXact)
        MyPgXact->xid = xid;    /* LWLockRelease acts as barrier */
    else
    {
        int         nxids = MyPgXact->nxids;

if (nxids < PGPROC_MAX_CACHED_SUBXIDS)
        {
            MyProc->subxids.xids[nxids] = xid;
            pg_write_barrier();
            MyPgXact->nxids = nxids + 1;
        }
        else
            MyPgXact->overflowed = true;
    }
    //釋放鎖
    LWLockRelease(XidGenLock);

return xid;
}
 
```

### 三、跟蹤分析
執行txid_current,觸發函式呼叫
```
14:26:26 (xdb@[local]:5432)testdb=#  begin;
BEGIN
14:26:50 (xdb@[local]:5432)testdb=#* select txid_current_if_assigned();
 txid_current_if_assigned 
--------------------------
                         
(1 row)

14:26:55 (xdb@[local]:5432)testdb=#* select txid_current();

```

啟動gdb,設定斷點
```
(gdb) b GetNewTransactionId
Breakpoint 6 at 0x545e80: file varsup.c, line 56.
(gdb) c
Continuing.

Breakpoint 6, GetNewTransactionId (isSubXact=false) at varsup.c:56
56      if (IsInParallelMode())
(gdb) 
```
檢視呼叫棧
```
(gdb) bt
#0  GetNewTransactionId (isSubXact=false) at varsup.c:56
#1  0x0000000000546bd9 in AssignTransactionId (s=0xf9c720 <toptransactionstatedata>) at xact.c:557
#2  0x000000000054693d in GetTopTransactionId () at xact.c:392
#3  0x00000000009fe1f3 in txid_current (fcinfo=0x254c7e0) at txid.c:443
#4  0x00000000006cfebd in ExecInterpExpr (state=0x254c6f8, econtext=0x254c3e8, isnull=0x7ffe3d4a31f7)
    at execExprInterp.c:654
#5  0x00000000006d1ac6 in ExecInterpExprStillValid (state=0x254c6f8, econtext=0x254c3e8, isNull=0x7ffe3d4a31f7)
    at execExprInterp.c:1786
#6  0x00000000007140dd in ExecEvalExprSwitchContext (state=0x254c6f8, econtext=0x254c3e8, isNull=0x7ffe3d4a31f7)
    at ../../../src/include/executor/executor.h:303
#7  0x000000000071414b in ExecProject (projInfo=0x254c6f0) at ../../../src/include/executor/executor.h:337
#8  0x0000000000714323 in ExecResult (pstate=0x254c2d0) at nodeResult.c:136
#9  0x00000000006e4c30 in ExecProcNodeFirst (node=0x254c2d0) at execProcnode.c:445
#10 0x00000000006d9974 in ExecProcNode (node=0x254c2d0) at ../../../src/include/executor/executor.h:237
#11 0x00000000006dc22d in ExecutePlan (estate=0x254c0b8, planstate=0x254c2d0, use_parallel_mode=false, 
    operation=CMD_SELECT, sendTuples=true, numberTuples=0, direction=ForwardScanDirection, dest=0x24ccf10, 
    execute_once=true) at execMain.c:1723
#12 0x00000000006d9f5c in standard_ExecutorRun (queryDesc=0x256b8e8, direction=ForwardScanDirection, count=0, 
    execute_once=true) at execMain.c:364
#13 0x00000000006d9d7f in ExecutorRun (queryDesc=0x256b8e8, direction=ForwardScanDirection, count=0, execute_once=true)
    at execMain.c:307
#14 0x00000000008ccf5a in PortalRunSelect (portal=0x250c860, forward=true, count=0, dest=0x24ccf10) at pquery.c:932
#15 0x00000000008ccbf3 in PortalRun (portal=0x250c860, count=9223372036854775807, isTopLevel=true, run_once=true, 
    dest=0x24ccf10, altdest=0x24ccf10, completionTag=0x7ffe3d4a3570 "") at pquery.c:773
#16 0x00000000008c6b1e in exec_simple_query (query_string=0x24a6ec8 "select txid_current();") at postgres.c:1145
#17 0x00000000008cae70 in PostgresMain (argc=1, argv=0x24d2dc8, dbname=0x24d2c30 "testdb", username=0x24a3ba8 "xdb")
    at postgres.c:4182
---Type <return> to continue, or q <return> to quit---
#18 0x000000000082642b in BackendRun (port=0x24c8c00) at postmaster.c:4361
#19 0x0000000000825b8f in BackendStartup (port=0x24c8c00) at postmaster.c:4033
#20 0x0000000000821f1c in ServerLoop () at postmaster.c:1706
#21 0x00000000008217b4 in PostmasterMain (argc=1, argv=0x24a1b60) at postmaster.c:1379
#22 0x00000000007488ef in main (argc=1, argv=0x24a1b60) at main.c:228
(gdb) 
```
獲取XidGenLock鎖
```
(gdb) n
63      if (IsBootstrapProcessingMode())
(gdb) 
71      if (RecoveryInProgress())
(gdb) 
74      LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
(gdb) 
```
獲取共享記憶體變數ShmemVariableCache->nextXid --> 2409

```
(gdb) 
76      xid = ShmemVariableCache->nextXid;
(gdb) 
91      if (TransactionIdFollowsOrEquals(xid, ShmemVariableCache->xidVacLimit))
(gdb) p *ShmemVariableCache
$16 = {nextOid = 42628, oidCount = 8191, nextXid = 2409, oldestXid = 561, xidVacLimit = 200000561, 
  xidWarnLimit = 2136484208, xidStopLimit = 2146484208, xidWrapLimit = 2147484208, oldestXidDB = 16400, 
  oldestCommitTsXid = 0, newestCommitTsXid = 0, latestCompletedXid = 2408, oldestClogXid = 561}
(gdb) 
```
擴充套件clog
```
(gdb) n
171     ExtendCLOG(xid);
(gdb) 
172     ExtendCommitTs(xid);
(gdb) 
173     ExtendSUBTRANS(xid);
(gdb) 
181     TransactionIdAdvance(ShmemVariableCache->nextXid);
(gdb) 
```
ShmemVariableCache->nextXid++ --> 2410
```
(gdb) p ShmemVariableCache->nextXid
$17 = 2410
```
獲取程式和事務資訊
```
(gdb) n
223         volatile PGXACT *mypgxact = MyPgXact;
(gdb) 
225         if (!isSubXact)
(gdb) 
226             mypgxact->xid = xid;
(gdb) 
```
釋放鎖XidGenLock
```
(gdb) 
241     LWLockRelease(XidGenLock);
(gdb) p *ShmemVariableCache
$18 = {nextOid = 42628, oidCount = 8191, nextXid = 2410, oldestXid = 561, xidVacLimit = 200000561, 
  xidWarnLimit = 2136484208, xidStopLimit = 2146484208, xidWrapLimit = 2147484208, oldestXidDB = 16400, 
  oldestCommitTsXid = 0, newestCommitTsXid = 0, latestCompletedXid = 2408, oldestClogXid = 561}
```
返回xid(2409),完成呼叫.
```
(gdb) n
243     return xid;
(gdb) 
244 }
(gdb) 
AssignTransactionId (s=0xf9c720 <toptransactionstatedata>) at xact.c:558
558     if (!isSubXact)
(gdb) 
```
DONE!

### 四、參考資料
[PG Source Code](https://doxygen.postgresql.org)</toptransactionstatedata></return></return></toptransactionstatedata>

PostgreSQL 原始碼解讀（121）- MVCC#6(獲取事務號-實現函式)

相關文章