本節介紹了PostgreSQL提交事務的整體處理邏輯,主要解析了函式CommitTransaction的實現邏輯。

### 一、資料結構
**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;

```

### 二、原始碼解讀
CommitTransaction函式,提交事務,並執行相關的清理操作.
```
/*
 *  CommitTransaction
 *
 * NB: if you change this routine, better look at PrepareTransaction too!
 * 注意:如果改變了這個過程的邏輯,最好同時處理PrepareTransaction.
 */
static void
CommitTransaction(void)
{
    TransactionState s = CurrentTransactionState;
    TransactionId latestXid;
    bool        is_parallel_worker;

is_parallel_worker = (s->blockState == TBLOCK_PARALLEL_INPROGRESS);

/* Enforce parallel mode restrictions during parallel worker commit. */
    //如為並行worker,強制進入並行模式
    if (is_parallel_worker)
        EnterParallelMode();

ShowTransactionState("CommitTransaction");

/*
     * check the current transaction state
     * 檢查當前事務狀態
     */
    if (s->state != TRANS_INPROGRESS)
        elog(WARNING, "CommitTransaction while in %s state",
             TransStateAsString(s->state));
    Assert(s->parent == NULL);

/*
     * Do pre-commit processing that involves calling user-defined code, such
     * as triggers.  Since closing cursors could queue trigger actions,
     * triggers could open cursors, etc, we have to keep looping until there's
     * nothing left to do.
     * 執行涉及呼叫使用者定義程式碼(如觸發器)的預提交處理。
     * 因為關閉遊標可能會執行觸發器，觸發器可能開啟遊標，等等，
     *   所以我們必須一直迴圈，直到沒有什麼可做的。
     */
    for (;;)
    {
        /*
         * Fire all currently pending deferred triggers.
         * 觸發所有當前活動的觸發器
         */
        AfterTriggerFireDeferred();

/*
         * Close open portals (converting holdable ones into static portals).
         * If there weren't any, we are done ... otherwise loop back to check
         * if they queued deferred triggers.  Lather, rinse, repeat.
         * 關閉開啟的portals(將可持有門戶轉換為靜態門戶).
         * 如果已不存在,則說明已完成.
         *   否則一直迴圈檢查觸發器佇列.
         */
        if (!PreCommit_Portals(false))
            break;
    }

CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_PRE_COMMIT
                      : XACT_EVENT_PRE_COMMIT);

/*
     * The remaining actions cannot call any user-defined code, so it's safe
     * to start shutting down within-transaction services.  But note that most
     * of this stuff could still throw an error, which would switch us into
     * the transaction-abort path.
     * 其餘的操作不能呼叫任何使用者定義的程式碼，因此可以安全地開始關閉事務內的服務。
     * 但是請注意，大多數這些動作仍然會丟擲錯誤，這將把執行流程切換到事務中止執行路徑上。
     */

/* If we might have parallel workers, clean them up now. */
    //存在並行worker,清除之
    if (IsInParallelMode())
        AtEOXact_Parallel(true);

/* Shut down the deferred-trigger manager */
    //關閉延遲觸發器管理器
    AfterTriggerEndXact(true);

/*
     * Let ON COMMIT management do its thing (must happen after closing
     * cursors, to avoid dangling-reference problems)
     * 讓ON COMMIT管理器執行這個事情.
     * (必須在關閉遊標後發生，以避免掛起引用問題)
     */
    PreCommit_on_commit_actions();

/* close large objects before lower-level cleanup */
    //在低階別的清理請,關閉大物件
    AtEOXact_LargeObject(true);

/*
     * Mark serializable transaction as complete for predicate locking
     * purposes.  This should be done as late as we can put it and still allow
     * errors to be raised for failure patterns found at commit.
     * 將可序列化事務標記為謂詞鎖定完成。
     * 這應該儘可能遲地完成，並且仍然允許在提交時發現的失敗從而引發錯誤。
     */
    PreCommit_CheckForSerializationFailure();

/*
     * Insert notifications sent by NOTIFY commands into the queue.  This
     * should be late in the pre-commit sequence to minimize time spent
     * holding the notify-insertion lock.
     * 將NOTIFY命令傳送的通知插入到佇列中。
     * 這應該在預提交序列的末尾，以最小化持有通知插入鎖的時間。
     */
    PreCommit_Notify();

/* Prevent cancel/die interrupt while cleaning up */
    //在清理時禁用中斷
    HOLD_INTERRUPTS();

/* Commit updates to the relation map --- do this as late as possible */
    //提交更新到relation map -- 儘可能晚的執行該動作
    AtEOXact_RelationMap(true, is_parallel_worker);

/*
     * set the current transaction state information appropriately during
     * commit processing
     * 在commit過程中設定當前事務狀態資訊.
     */
    s->state = TRANS_COMMIT;
    s->parallelModeLevel = 0;

if (!is_parallel_worker)
    {
        /*
         * We need to mark our XIDs as committed in pg_xact.  This is where we
         * durably commit.
         * 我們需要在pg_xact中將xid標記為已提交。
         */
        latestXid = RecordTransactionCommit();
    }
    else
    {
        /*
         * We must not mark our XID committed; the parallel master is
         * responsible for that.
         * 並行worker,不需要標記XID的提交標記,並行管理器處理此事情.
         */
        latestXid = InvalidTransactionId;

/*
         * Make sure the master will know about any WAL we wrote before it
         * commits.
         * 確保master在提交之前知道worker寫入的WAL。
         */
        ParallelWorkerReportLastRecEnd(XactLastRecEnd);
    }

TRACE_POSTGRESQL_TRANSACTION_COMMIT(MyProc->lxid);

/*
     * Let others know about no transaction in progress by me. Note that this
     * must be done _before_ releasing locks we hold and _after_
     * RecordTransactionCommit.
     * 通知其他程式知道該程式沒有進行中的事務。
     * 注意，這必須在釋放持有的鎖之前執行，並在RecordTransactionCommit之後執行。
     */
    ProcArrayEndTransaction(MyProc, latestXid);

/*
     * This is all post-commit cleanup.  Note that if an error is raised here,
     * it's too late to abort the transaction.  This should be just
     * noncritical resource releasing.
     * 這些都是提交後清理。
     * 請注意，如果這裡出現錯誤，則終止事務就太遲了.
     * 這應該是非關鍵的資源釋放。
     *
     * The ordering of operations is not entirely random.  The idea is:
     * release resources visible to other backends (eg, files, buffer pins);
     * then release locks; then release backend-local resources. We want to
     * release locks at the point where any backend waiting for us will see
     * our transaction as being fully cleaned up.
     * 操作的順序並不是完全隨機的。
     * 其思想是:釋放對其他後臺程式可見的資源(如檔案、buffer pins);
     *   然後釋放鎖;然後釋放後端本地資源。
     * 我們希望在所有等待我們的後臺程式看到我們的事務被完全清理的時候才釋放鎖。
     *
     * Resources that can be associated with individual queries are handled by
     * the ResourceOwner mechanism.  The other calls here are for backend-wide
     * state.
     * 與單個查詢關聯的資源由ResourceOwner機制處理。
     * 這裡的其他呼叫是針對後臺程式範圍的狀態的。
     */

CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_COMMIT
                      : XACT_EVENT_COMMIT);

ResourceOwnerRelease(TopTransactionResourceOwner,
                         RESOURCE_RELEASE_BEFORE_LOCKS,
                         true, true);

/* Check we've released all buffer pins */
    //檢查已釋放所有的buffer pins
    AtEOXact_Buffers(true);

/* Clean up the relation cache */
    //清理關係快取
    AtEOXact_RelationCache(true);

/*
     * Make catalog changes visible to all backends.  This has to happen after
     * relcache references are dropped (see comments for
     * AtEOXact_RelationCache), but before locks are released (if anyone is
     * waiting for lock on a relation we've modified, we want them to know
     * about the catalog change before they start using the relation).
     * 使目錄更改對所有後臺程式可見。
     * 這必須發生在relcache引用被刪除之後(參見AtEOXact_RelationCache註釋)，
     *   但是在鎖被釋放之前(如果有人在等待我們修改的關係的鎖，我們希望他們在開始使用關係之前知道目錄的更改)。
     */
    AtEOXact_Inval(true);

AtEOXact_MultiXact();

ResourceOwnerRelease(TopTransactionResourceOwner,
                         RESOURCE_RELEASE_LOCKS,
                         true, true);
    ResourceOwnerRelease(TopTransactionResourceOwner,
                         RESOURCE_RELEASE_AFTER_LOCKS,
                         true, true);

/*
     * Likewise, dropping of files deleted during the transaction is best done
     * after releasing relcache and buffer pins.  (This is not strictly
     * necessary during commit, since such pins should have been released
     * already, but this ordering is definitely critical during abort.)  Since
     * this may take many seconds, also delay until after releasing locks.
     * Other backends will observe the attendant catalog changes and not
     * attempt to access affected files.
     * 同樣，在事務期間刪除的檔案的清理最好在釋放relcache和buffer pin之後進行。
     * (這在提交過程中並不是必須的，因為這樣的pins應該已經被釋放了，
     *  但是該順序在中止過程中絕對是至關重要的。)
     * 因為這可能需要較長的時間，所以也要延遲到釋放鎖之後。
     * 其他後臺程式將監控相關的catalog更改，不嘗試訪問受影響的檔案。
     */
    smgrDoPendingDeletes(true);

AtCommit_Notify();
    AtEOXact_GUC(true, 1);
    AtEOXact_SPI(true);
    AtEOXact_Enum();
    AtEOXact_on_commit_actions(true);
    AtEOXact_Namespace(true, is_parallel_worker);
    AtEOXact_SMgr();
    AtEOXact_Files(true);
    AtEOXact_ComboCid();
    AtEOXact_HashTables(true);
    AtEOXact_PgStat(true);
    AtEOXact_Snapshot(true, false);
    AtEOXact_ApplyLauncher(true);
    pgstat_report_xact_timestamp(0);

CurrentResourceOwner = NULL;
    ResourceOwnerDelete(TopTransactionResourceOwner);
    s->curTransactionOwner = NULL;
    CurTransactionResourceOwner = NULL;
    TopTransactionResourceOwner = NULL;

AtCommit_Memory();

s->transactionId = InvalidTransactionId;
    s->subTransactionId = InvalidSubTransactionId;
    s->nestingLevel = 0;
    s->gucNestLevel = 0;
    s->childXids = NULL;
    s->nChildXids = 0;
    s->maxChildXids = 0;

XactTopTransactionId = InvalidTransactionId;
    nParallelCurrentXids = 0;

/*
     * done with commit processing, set current transaction state back to
     * default
     * 完成提交處理後，將當前事務狀態設定為default
     */
    s->state = TRANS_DEFAULT;

RESUME_INTERRUPTS();
}
 
```

### 三、跟蹤分析
插入資料,執行commit
```
10:57:56 (xdb@[local]:5432)testdb=# begin;
BEGIN
10:57:59 (xdb@[local]:5432)testdb=#* insert into t_session1 values(1);
INSERT 0 1
10:58:01 (xdb@[local]:5432)testdb=#* commit;
```

啟動gdb,設定斷點
```
(gdb) b CommitTransaction
Breakpoint 1 at 0x5482ae: file xact.c, line 1969.
(gdb) c
Continuing.

Breakpoint 1, CommitTransaction () at xact.c:1969
1969        TransactionState s = CurrentTransactionState;
(gdb) 
```
檢視呼叫棧
```
(gdb) bt
#0  CommitTransaction () at xact.c:1969
#1  0x0000000000549078 in CommitTransactionCommand () at xact.c:2831
#2  0x00000000008c8ea9 in finish_xact_command () at postgres.c:2523
#3  0x00000000008c6b5d in exec_simple_query (query_string=0x2c97ec8 "commit;") at postgres.c:1170
#4  0x00000000008cae70 in PostgresMain (argc=1, argv=0x2cc3dc8, dbname=0x2cc3c30 "testdb", username=0x2c94ba8 "xdb")
    at postgres.c:4182
#5  0x000000000082642b in BackendRun (port=0x2cb9c00) at postmaster.c:4361
#6  0x0000000000825b8f in BackendStartup (port=0x2cb9c00) at postmaster.c:4033
#7  0x0000000000821f1c in ServerLoop () at postmaster.c:1706
#8  0x00000000008217b4 in PostmasterMain (argc=1, argv=0x2c92b60) at postmaster.c:1379
#9  0x00000000007488ef in main (argc=1, argv=0x2c92b60) at main.c:228
(gdb) 
```
當前事務資訊
```
(gdb) p *s
$1 = {transactionId = 2410, subTransactionId = 1, name = 0x0, savepointLevel = 0, state = TRANS_INPROGRESS, 
  blockState = TBLOCK_END, nestingLevel = 1, gucNestLevel = 1, curTransactionContext = 0x2d3cfa0, 
  curTransactionOwner = 0x2cc5868, childXids = 0x0, nChildXids = 0, maxChildXids = 0, prevUser = 10, prevSecContext = 0, 
  prevXactReadOnly = false, startedInRecovery = false, didLogXid = true, parallelModeLevel = 0, parent = 0x0}
(gdb) 
```
執行相關判斷,執行預處理等
```
(gdb) n
1976        if (is_parallel_worker)
(gdb) 
1979        ShowTransactionState("CommitTransaction");
(gdb) 
1984        if (s->state != TRANS_INPROGRESS)
(gdb) 
1987        Assert(s->parent == NULL);
(gdb) 
2000            AfterTriggerFireDeferred();
(gdb) 
2007            if (!PreCommit_Portals(false))
(gdb) 
2008                break;
(gdb) 
2011        CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_PRE_COMMIT
(gdb) 
```
繼續執行預處理
```
(gdb) n
2022        if (IsInParallelMode())
(gdb) 
2026        AfterTriggerEndXact(true);
(gdb) 
2032        PreCommit_on_commit_actions();
(gdb) 
2035        AtEOXact_LargeObject(true);
(gdb) 
(gdb) 
2042        PreCommit_CheckForSerializationFailure();
(gdb) 
2049        PreCommit_Notify();
(gdb) 
2052        HOLD_INTERRUPTS();
(gdb) 
2055        AtEOXact_RelationMap(true);
(gdb) 
```
修改事務狀態
```
2061        s->state = TRANS_COMMIT;
(gdb) 
2062        s->parallelModeLevel = 0;
(gdb)
```
執行實際的提交事務操作
```
(gdb) 
2064        if (!is_parallel_worker)
(gdb) 
2070            latestXid = RecordTransactionCommit();
(gdb) 
2087        TRACE_POSTGRESQL_TRANSACTION_COMMIT(MyProc->lxid);
(gdb) 
```
通知其他程式知道該程式沒有進行中的事務。
```
(gdb) 
2094        ProcArrayEndTransaction(MyProc, latestXid);
(gdb) 
2112        CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_COMMIT
(gdb) 
```
釋放資源
```
(gdb) 
2115        ResourceOwnerRelease(TopTransactionResourceOwner,
(gdb) 
2120        AtEOXact_Buffers(true);
(gdb) 
2123        AtEOXact_RelationCache(true);
(gdb) 
2132        AtEOXact_Inval(true);
(gdb) 
2134        AtEOXact_MultiXact();
(gdb) 
2136        ResourceOwnerRelease(TopTransactionResourceOwner,
(gdb) 
2139        ResourceOwnerRelease(TopTransactionResourceOwner,

```
執行清理操作
```
(gdb) 
2152        smgrDoPendingDeletes(true);
(gdb) 
2154        AtCommit_Notify();
(gdb) 
2155        AtEOXact_GUC(true, 1);
(gdb) 
2156        AtEOXact_SPI(true);
(gdb) 
2157        AtEOXact_on_commit_actions(true);
(gdb) 
2158        AtEOXact_Namespace(true, is_parallel_worker);
(gdb) 
2159        AtEOXact_SMgr();
(gdb) 
2160        AtEOXact_Files(true);
(gdb) 
2161        AtEOXact_ComboCid();
(gdb) 
2162        AtEOXact_HashTables(true);
(gdb) 
2163        AtEOXact_PgStat(true);
(gdb) 
2164        AtEOXact_Snapshot(true, false);
(gdb) 
2165        AtEOXact_ApplyLauncher(true);
(gdb) 
2166        pgstat_report_xact_timestamp(0);
(gdb) 
2168        CurrentResourceOwner = NULL;
(gdb) 
2169        ResourceOwnerDelete(TopTransactionResourceOwner);
(gdb) 
2170        s->curTransactionOwner = NULL;
(gdb) 
```
重置事務狀態
```
(gdb) 
2171        CurTransactionResourceOwner = NULL;
(gdb) 
2172        TopTransactionResourceOwner = NULL;
(gdb) 
2174        AtCommit_Memory();
(gdb) 
2176        s->transactionId = InvalidTransactionId;
(gdb) 
2177        s->subTransactionId = InvalidSubTransactionId;
(gdb) 
2178        s->nestingLevel = 0;
(gdb) 
2179        s->gucNestLevel = 0;
(gdb) 
2180        s->childXids = NULL;
(gdb) 
2181        s->nChildXids = 0;
(gdb) 
2182        s->maxChildXids = 0;
(gdb) 
2184        XactTopTransactionId = InvalidTransactionId;
(gdb) 
2185        nParallelCurrentXids = 0;
(gdb) 
2191        s->state = TRANS_DEFAULT;
(gdb) 
2193        RESUME_INTERRUPTS();
(gdb) 
2194    }
(gdb) 
```
重置後的事務狀態
```
(gdb) p *s
$2 = {transactionId = 0, subTransactionId = 0, name = 0x0, savepointLevel = 0, state = TRANS_DEFAULT, 
  blockState = TBLOCK_END, nestingLevel = 0, gucNestLevel = 0, curTransactionContext = 0x0, curTransactionOwner = 0x0, 
  childXids = 0x0, nChildXids = 0, maxChildXids = 0, prevUser = 10, prevSecContext = 0, prevXactReadOnly = false, 
  startedInRecovery = false, didLogXid = true, parallelModeLevel = 0, parent = 0x0}
(gdb) 
```
執行完畢
```
(gdb) n
CommitTransactionCommand () at xact.c:2832
2832                s->blockState = TBLOCK_DEFAULT;
(gdb) 
```
DONE!

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

PostgreSQL 原始碼解讀（122）- MVCC#7(提交事務-整體流程)

相關文章