本節介紹了PostgreSQL獲取事務快照的實現邏輯,重點解析了GetTransactionSnapshot->GetSnapshotData的處理過程。

### 一、資料結構
**全域性/靜態變數**
```
/*
 * Currently registered Snapshots.  Ordered in a heap by xmin, so that we can
 * quickly find the one with lowest xmin, to advance our MyPgXact->xmin.
 * 當前已註冊的快照.
 * 按照xmin堆排序，這樣我們可以快速找到xmin最小的一個，從而可以設定MyPgXact->xmin。
 */
static int xmin_cmp(const pairingheap_node *a, const pairingheap_node *b,
 void *arg);

static pairingheap RegisteredSnapshots = {&xmin_cmp, NULL, NULL};

/* first GetTransactionSnapshot call in a transaction? */
bool        FirstSnapshotSet = false;

/*
 * Remember the serializable transaction snapshot, if any.  We cannot trust
 * FirstSnapshotSet in combination with IsolationUsesXactSnapshot(), because
 * GUC may be reset before us, changing the value of IsolationUsesXactSnapshot.
 * 如存在則記下serializable事務快照.
 * 我們不能信任與IsolationUsesXactSnapshot()結合使用的FirstSnapshotSet，
 *   因為GUC可能會在我們之前重置，改變IsolationUsesXactSnapshot的值。
 */
static Snapshot FirstXactSnapshot = NULL;

/*
 * CurrentSnapshot points to the only snapshot taken in transaction-snapshot
 * mode, and to the latest one taken in a read-committed transaction.
 * SecondarySnapshot is a snapshot that's always up-to-date as of the current
 * instant, even in transaction-snapshot mode.  It should only be used for
 * special-purpose code (say, RI checking.)  CatalogSnapshot points to an
 * MVCC snapshot intended to be used for catalog scans; we must invalidate it
 * whenever a system catalog change occurs.
 * CurrentSnapshot指向在transaction-snapshot模式下獲取的唯一快照/在read-committed事務中獲取的最新快照。
 * SecondarySnapshot是即使在transaction-snapshot模式下，也總是最新的快照。它應該只用於特殊用途碼(例如，RI檢查)。
 * CatalogSnapshot指向打算用於catalog掃描的MVCC快照;
 *  無論何時發生system catalog更改，我們都必須馬上使其失效。
 *
 * These SnapshotData structs are static to simplify memory allocation
 * (see the hack in GetSnapshotData to avoid repeated malloc/free).
 * 這些SnapshotData結構體是靜態的便於簡化記憶體分配.
 * (可以回過頭來看GetSnapshotData函式如何避免重複的malloc/free)
 */
static SnapshotData CurrentSnapshotData = {HeapTupleSatisfiesMVCC};
static SnapshotData SecondarySnapshotData = {HeapTupleSatisfiesMVCC};
SnapshotData CatalogSnapshotData = {HeapTupleSatisfiesMVCC};

/* Pointers to valid snapshots */
//指向有效的快照
static Snapshot CurrentSnapshot = NULL;
static Snapshot SecondarySnapshot = NULL;
static Snapshot CatalogSnapshot = NULL;
static Snapshot HistoricSnapshot = NULL;

/*
 * These are updated by GetSnapshotData.  We initialize them this way
 * for the convenience of TransactionIdIsInProgress: even in bootstrap
 * mode, we don't want it to say that BootstrapTransactionId is in progress.
 * 這些變數透過函式GetSnapshotData更新.
 * 為了便於TransactionIdIsInProgress，以這種方式初始化它們:
 *   即使在引導模式下，我們也不希望表示BootstrapTransactionId正在進行中。
 *
 * RecentGlobalXmin and RecentGlobalDataXmin are initialized to
 * InvalidTransactionId, to ensure that no one tries to use a stale
 * value. Readers should ensure that it has been set to something else
 * before using it.
 * RecentGlobalXmin和RecentGlobalDataXmin初始化為InvalidTransactionId,
 *   以確保沒有人嘗試使用過時的值。
 * 在使用它之前，讀取程式應確保它已經被設定為其他值。
 */
TransactionId TransactionXmin = FirstNormalTransactionId;
TransactionId RecentXmin = FirstNormalTransactionId;
TransactionId RecentGlobalXmin = InvalidTransactionId;
TransactionId RecentGlobalDataXmin = InvalidTransactionId;

/* (table, ctid) => (cmin, cmax) mapping during timetravel */
static HTAB *tuplecid_data = NULL;

```

**MyPgXact**
當前的事務資訊.
```
/*
 * Flags for PGXACT->vacuumFlags
 * PGXACT->vacuumFlags標記
 *
 * Note: If you modify these flags, you need to modify PROCARRAY_XXX flags
 * in src/include/storage/procarray.h.
 * 注意:如果修改了這些標記,需要更新src/include/storage/procarray.h中的PROCARRAY_XXX標記
 *
 * PROC_RESERVED may later be assigned for use in vacuumFlags, but its value is
 * used for PROCARRAY_SLOTS_XMIN in procarray.h, so GetOldestXmin won't be able
 * to match and ignore processes with this flag set.
 * PROC_RESERVED可能在接下來分配給vacuumFlags使用,
 *   但是它在procarray.h中用於標識PROCARRAY_SLOTS_XMIN,
 *   因此GetOldestXmin不能匹配和忽略使用此標記的程式.
 */
//是否auto vacuum worker?
#define     PROC_IS_AUTOVACUUM  0x01    /* is it an autovac worker? */
//正在執行lazy vacuum
#define     PROC_IN_VACUUM      0x02    /* currently running lazy vacuum */
//正在執行analyze
#define     PROC_IN_ANALYZE     0x04    /* currently running analyze */
//只能透過auto vacuum設定
#define     PROC_VACUUM_FOR_WRAPAROUND  0x08    /* set by autovac only */
//在事務外部正在執行邏輯解碼
#define     PROC_IN_LOGICAL_DECODING    0x10    /* currently doing logical
                                                 * decoding outside xact */
//保留用於procarray
#define     PROC_RESERVED               0x20    /* reserved for procarray */

/* flags reset at EOXact */
//在EOXact時用於重置標記的MASK
#define     PROC_VACUUM_STATE_MASK \
    (PROC_IN_VACUUM | PROC_IN_ANALYZE | PROC_VACUUM_FOR_WRAPAROUND)

/*
 * Prior to PostgreSQL 9.2, the fields below were stored as part of the
 * PGPROC.  However, benchmarking revealed that packing these particular
 * members into a separate array as tightly as possible sped up GetSnapshotData
 * considerably on systems with many CPU cores, by reducing the number of
 * cache lines needing to be fetched.  Thus, think very carefully before adding
 * anything else here.
 */
typedef struct PGXACT
{
    //當前的頂層事務ID(非子事務)
    //出於最佳化的目的,只讀事務並不會分配事務號(xid = 0)
    TransactionId xid;          /* id of top-level transaction currently being
                                 * executed by this proc, if running and XID
                                 * is assigned; else InvalidTransactionId */
    //在啟動事務時,當前正在執行的最小事務號XID,但不包括LAZY VACUUM
    //vacuum不能清除刪除事務號xid >= xmin的元組
    TransactionId xmin;         /* minimal running XID as it was when we were
                                 * starting our xact, excluding LAZY VACUUM:
                                 * vacuum must not remove tuples deleted by
                                 * xid >= xmin ! */
    //vacuum相關的標記
    uint8       vacuumFlags;    /* vacuum-related flags, see above */
    bool        overflowed;
    bool        delayChkpt;     /* true if this proc delays checkpoint start;
                                 * previously called InCommit */

uint8       nxids;
} PGXACT;
 
extern PGDLLIMPORT struct PGXACT *MyPgXact;

```

**Snapshot**
SnapshotData結構體指標,SnapshotData結構體可表達的資訊囊括了所有可能的快照.
有以下幾種不同型別的快照:
1.常規的MVCC快照
2.在恢復期間的MVCC快照(處於Hot-Standby模式)
3.在邏輯解碼過程中使用的歷史MVCC快照
4.作為引數傳遞給HeapTupleSatisfiesDirty()函式的快照
5.作為引數傳遞給HeapTupleSatisfiesNonVacuumable()函式的快照
6.用於在沒有成員訪問情況下SatisfiesAny、Toast和Self的快照

```

//SnapshotData結構體指標
typedef struct SnapshotData *Snapshot;
//無效的快照
#define InvalidSnapshot     ((Snapshot) NULL)

/*
 * We use SnapshotData structures to represent both "regular" (MVCC)
 * snapshots and "special" snapshots that have non-MVCC semantics.
 * The specific semantics of a snapshot are encoded by the "satisfies"
 * function.
 * 我們使用SnapshotData結構體表示"regular" (MVCC) snapshots和具有非MVCC語義的"special" snapshots。
 */
//測試函式
typedef bool (*SnapshotSatisfiesFunc) (HeapTuple htup,
                                       Snapshot snapshot, Buffer buffer);
//常見的有:

//HeapTupleSatisfiesMVCC：判斷元組對某一快照版本是否有效
//HeapTupleSatisfiesUpdate：判斷元組是否可更新(同時更新同一個元組)
//HeapTupleSatisfiesDirty：判斷當前元組是否存在髒資料
//HeapTupleSatisfiesSelf：判斷tuple對自身資訊是否有效
//HeapTupleSatisfiesToast：判斷是否TOAST表
//HeapTupleSatisfiesVacuum：判斷元組是否能被VACUUM刪除
//HeapTupleSatisfiesAny：所有元組都可見
//HeapTupleSatisfiesHistoricMVCC：用於CATALOG 表

/*
 * Struct representing all kind of possible snapshots.
 * 該結構體可表達的資訊囊括了所有可能的快照.
 * 
 * There are several different kinds of snapshots:
 * * Normal MVCC snapshots
 * * MVCC snapshots taken during recovery (in Hot-Standby mode)
 * * Historic MVCC snapshots used during logical decoding
 * * snapshots passed to HeapTupleSatisfiesDirty()
 * * snapshots passed to HeapTupleSatisfiesNonVacuumable()
 * * snapshots used for SatisfiesAny, Toast, Self where no members are
 *   accessed.
 * 有以下幾種不同型別的快照:
 * * 常規的MVCC快照
 * * 在恢復期間的MVCC快照(處於Hot-Standby模式)
 * * 在邏輯解碼過程中使用的歷史MVCC快照
 * * 作為引數傳遞給HeapTupleSatisfiesDirty()函式的快照
 * * 作為引數傳遞給HeapTupleSatisfiesNonVacuumable()函式的快照
 * * 用於在沒有成員訪問情況下SatisfiesAny、Toast和Self的快照
 *
 * TODO: It's probably a good idea to split this struct using a NodeTag
 * similar to how parser and executor nodes are handled, with one type for
 * each different kind of snapshot to avoid overloading the meaning of
 * individual fields.
 * TODO: 使用類似於parser/executor nodes的處理,使用NodeTag來拆分結構體會是一個好的做法,
 *       使用OO(物件導向繼承)的方法.
 */
typedef struct SnapshotData
{
    //測試tuple是否可見的函式
    SnapshotSatisfiesFunc satisfies;    /* tuple test function */

/*
     * The remaining fields are used only for MVCC snapshots, and are normally
     * just zeroes in special snapshots.  (But xmin and xmax are used
     * specially by HeapTupleSatisfiesDirty, and xmin is used specially by
     * HeapTupleSatisfiesNonVacuumable.)
     * 餘下的欄位僅用於MVCC快照，在特殊快照中通常為0。
     * (xmin和xmax可用於HeapTupleSatisfiesDirty，xmin可用於HeapTupleSatisfiesNonVacuumable)
     *
     * An MVCC snapshot can never see the effects of XIDs >= xmax. It can see
     * the effects of all older XIDs except those listed in the snapshot. xmin
     * is stored as an optimization to avoid needing to search the XID arrays
     * for most tuples.
     *  XIDs >= xmax的事務,對該快照是不可見的(沒有任何影響).
     * 對該快照可見的是小於xmax,但不在snapshot列表中的XIDs.
     * 記錄xmin是出於最佳化的目的,避免為大多數tuples搜尋XID陣列.
     */
    //XID ∈ [2,min)是可見的 
    TransactionId xmin;         /* all XID < xmin are visible to me */
    //XID ∈ [xmax,∞)是不可見的
    TransactionId xmax;         /* all XID >= xmax are invisible to me */

/*
     * For normal MVCC snapshot this contains the all xact IDs that are in
     * progress, unless the snapshot was taken during recovery in which case
     * it's empty. For historic MVCC snapshots, the meaning is inverted, i.e.
     * it contains *committed* transactions between xmin and xmax.
     * 對於普通的MVCC快照,xip儲存了所有正在進行中的XIDs,除非在恢復期間產生的快照(這時候陣列為空)
     * 對於歷史MVCC快照,意義相反，即它包含xmin和xmax之間的*已提交*事務。
     *
     * note: all ids in xip[] satisfy xmin <= xip[i] < xmax
     * 注意: 所有在xip陣列中的XIDs滿足xmin <= xip[i] < xmax
     */
    TransactionId *xip;
    //xip陣列中的元素個數
    uint32      xcnt;           /* # of xact ids in xip[] */

/*
     * For non-historic MVCC snapshots, this contains subxact IDs that are in
     * progress (and other transactions that are in progress if taken during
     * recovery). For historic snapshot it contains *all* xids assigned to the
     * replayed transaction, including the toplevel xid.
     * 對於非歷史MVCC快照,下面這些域含有活動的subxact IDs.
     *   (以及在恢復過程中狀態為進行中的事務).
     * 對於歷史MVCC快照,這些域欄位含有*所有*用於回放事務的快照,包括頂層事務XIDs.
     *
     * note: all ids in subxip[] are >= xmin, but we don't bother filtering
     * out any that are >= xmax
     * 注意:sbuxip陣列中的元素均≥ xmin,但我們不需要過濾掉任何>= xmax的項
     */
    TransactionId *subxip;
    //subxip陣列元素個數
    int32       subxcnt;        /* # of xact ids in subxip[] */
    //是否溢位?
    bool        suboverflowed;  /* has the subxip array overflowed? */

//在Recovery期間的快照?
    bool        takenDuringRecovery;    /* recovery-shaped snapshot? */
    //如為靜態快照,則該值為F
    bool        copied;         /* false if it's a static snapshot */

//在自身的事務中,CID < curcid是可見的
    CommandId   curcid;         /* in my xact, CID < curcid are visible */

/*
     * An extra return value for HeapTupleSatisfiesDirty, not used in MVCC
     * snapshots.
     * HeapTupleSatisfiesDirty返回的值,在MVCC快照中無用
     */
    uint32      speculativeToken;

/*
     * Book-keeping information, used by the snapshot manager
     * 用於快照管理器的Book-keeping資訊
     */
    //在ActiveSnapshot棧中的引用計數
    uint32      active_count;   /* refcount on ActiveSnapshot stack */
    //在RegisteredSnapshots中的引用計數
    uint32      regd_count;     /* refcount on RegisteredSnapshots */
    //RegisteredSnapshots堆中的連結
    pairingheap_node ph_node;   /* link in the RegisteredSnapshots heap */

//快照"拍攝"時間戳
    TimestampTz whenTaken;      /* timestamp when snapshot was taken */
    //拍照時WAL stream中的位置
    XLogRecPtr  lsn;            /* position in the WAL stream when taken */
} SnapshotData;

```

**ShmemVariableCache**
VariableCache是共享記憶體中的一種資料結構，用於跟蹤OID和XID分配狀態。
ShmemVariableCache是VariableCache結構體指標.
```
/*
 * 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;

```

### 二、原始碼解讀
GetSnapshotData函式返回快照資訊.
重點是構造xmin : xmax : xip_list,其實現邏輯簡單總結如下:
1.獲取xmax = ShmemVariableCache->latestCompletedXid + 1;
2.遍歷全域性procArray陣列,構建快照資訊
  2.1 獲取程式相應的事務資訊pgxact
  2.2 獲取程式事務ID(pgxact->xid),取最小的xid作為xmin(不包括0)
  2.3 把xid放入快照->xip陣列中(不包括本程式所在的事務id)
```
/*
 * GetSnapshotData -- returns information about running transactions.
 * GetSnapshotData -- 返回關於正在執行中的事務的相關資訊
 *
 * The returned snapshot includes xmin (lowest still-running xact ID),
 * xmax (highest completed xact ID + 1), and a list of running xact IDs
 * in the range xmin <= xid < xmax.  It is used as follows:
 *      All xact IDs < xmin are considered finished.
 *      All xact IDs >= xmax are considered still running.
 *      For an xact ID xmin <= xid < xmax, consult list to see whether
 *      it is considered running or not.
 * This ensures that the set of transactions seen as "running" by the
 * current xact will not change after it takes the snapshot.
 * 返回的snapshot包括xmin(最小的正在執行的事務ID),xmax(已完結事務ID + 1),
 *   以及在xmin <= xid < xmax之間正在執行的事務IDs.
 * 意義如下:
 *   事務IDs < xmin是已確定完成的事務.
 *   事務IDs >= xmax是正在執行的事務.
 *   對於XID ∈ [xmin,xmax)的事務,需查閱列表確認是否正在執行中
 *
 * All running top-level XIDs are included in the snapshot, except for lazy
 * VACUUM processes.  We also try to include running subtransaction XIDs,
 * but since PGPROC has only a limited cache area for subxact XIDs, full
 * information may not be available.  If we find any overflowed subxid arrays,
 * we have to mark the snapshot's subxid data as overflowed, and extra work
 * *may* need to be done to determine what's running (see XidInMVCCSnapshot()
 * in tqual.c).
 * 所有正在執行的頂層XIDs包含在快照中,除了lazy VACUUM程式.
 * 我們嘗試包含所有正在執行的子事務XIDs,但由於PGPROC只有有限的快取,包含所有的子事務資訊暫未實現.
 * 如果我們搜尋溢位的子事務陣列,我們必須標記快照的subxid資料為溢位,
 * 而且需要執行額外的工作以確定哪些在執行(檢視tqual.c中的XidInMVCCSnapshot()函式)
 *
 * We also update the following backend-global variables:
 *      TransactionXmin: the oldest xmin of any snapshot in use in the
 *          current transaction (this is the same as MyPgXact->xmin).
 *      RecentXmin: the xmin computed for the most recent snapshot.  XIDs
 *          older than this are known not running any more.
 *      RecentGlobalXmin: the global xmin (oldest TransactionXmin across all
 *          running transactions, except those running LAZY VACUUM).  This is
 *          the same computation done by
 *          GetOldestXmin(NULL, PROCARRAY_FLAGS_VACUUM).
 *      RecentGlobalDataXmin: the global xmin for non-catalog tables
 *          >= RecentGlobalXmin
 * 我們同時更新了以下後臺全域性變數:
 *      TransactionXmin: 當前事務中在所有仍在使用的快照中最舊的xmin(與MyPgXact->xmin一致).
 *      RecentXmin: 最近快照的xmin.小於xmin的事務已知已完結.
 *      RecentGlobalXmin:全域性的xmin(除了正在執行的LAZY VACUUM,跨越所有正在執行事務的最舊的TransactionXmin),
 *                       這是使用同樣的規則,透過GetOldestXmin(NULL, PROCARRAY_FLAGS_VACUUM)處理.
 *      RecentGlobalDataXmin:非catalog資料表的全域性xmin,該值>= RecentGlobalXmin.
 *
 * Note: this function should probably not be called with an argument that's
 * not statically allocated (see xip allocation below).
 * 注意:不應該使用非靜態分配的引數呼叫這個函式(參見下面的xip分配)。
 */
Snapshot
GetSnapshotData(Snapshot snapshot)
{
    ProcArrayStruct *arrayP = procArray;//程式陣列
    TransactionId xmin;//xmin
    TransactionId xmax;//xmax
    TransactionId globalxmin;//全域性xmin
    int         index;
    int         count = 0;
    int         subcount = 0;
    bool        suboverflowed = false;
    TransactionId replication_slot_xmin = InvalidTransactionId;
    TransactionId replication_slot_catalog_xmin = InvalidTransactionId;

Assert(snapshot != NULL);

/*
     * Allocating space for maxProcs xids is usually overkill; numProcs would
     * be sufficient.  But it seems better to do the malloc while not holding
     * the lock, so we can't look at numProcs.  Likewise, we allocate much
     * more subxip storage than is probably needed.
     * 為maxProcs xids分配空間通常是多餘的;numProcs就足夠了。
     * 但是在不持有鎖的情況下執行malloc似乎更好，因此我們不能檢視numProcs。
     * 同樣地，我們分配的子xip儲存可能比實際需要的多得多。
     *
     * This does open a possibility for avoiding repeated malloc/free: since
     * maxProcs does not change at runtime, we can simply reuse the previous
     * xip arrays if any.  (This relies on the fact that all callers pass
     * static SnapshotData structs.)
     * 這確實為避免重複的malloc/free創造了一種可能性:因為maxProcs在執行時不會改變，
     *   如果有的話，我們可以簡單地重用前面的xip陣列。
     * (這依賴於所有呼叫者都傳遞靜態快照資料結構這一事實。)
     */
    if (snapshot->xip == NULL)
    {
        /*
         * First call for this snapshot. Snapshot is same size whether or not
         * we are in recovery, see later comments.
         * 首次呼叫.快照的大小不管是在常規還是在恢復狀態都是一樣的,看稍後的註釋.
         */
        snapshot->xip = (TransactionId *)
            malloc(GetMaxSnapshotXidCount() * sizeof(TransactionId));
        if (snapshot->xip == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of memory")));
        Assert(snapshot->subxip == NULL);
        snapshot->subxip = (TransactionId *)
            malloc(GetMaxSnapshotSubxidCount() * sizeof(TransactionId));
        if (snapshot->subxip == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of memory")));
    }

/*
     * It is sufficient to get shared lock on ProcArrayLock, even if we are
     * going to set MyPgXact->xmin.
     * 即使我們要設定MyPgXact->xmin,也需要獲取鎖,在ProcArrayLock上獲得共享鎖就足夠了.
     * 
     */
    LWLockAcquire(ProcArrayLock, LW_SHARED);

/* xmax is always latestCompletedXid + 1 */
    //xmax = latestCompletedXid + 1
    //已完結事務號 + 1
    xmax = ShmemVariableCache->latestCompletedXid;
    Assert(TransactionIdIsNormal(xmax));
    TransactionIdAdvance(xmax);// + 1

/* initialize xmin calculation with xmax */
    //初始化xmin為xmax
    globalxmin = xmin = xmax;
    //是否處於恢復過程中?
    snapshot->takenDuringRecovery = RecoveryInProgress();

if (!snapshot->takenDuringRecovery)
    {
        //不是,正常執行中
        int        *pgprocnos = arrayP->pgprocnos;//程式數
        int         numProcs;

/*
         * Spin over procArray checking xid, xmin, and subxids.  The goal is
         * to gather all active xids, find the lowest xmin, and try to record
         * subxids.
         * Spin Over procArray,檢查xid/xmin和subxids.
         * 目標是蒐集所有活動的xids,找到最小的xmin,並嘗試記錄subxids.
         */
        numProcs = arrayP->numProcs;
        for (index = 0; index < numProcs; index++)//遍歷procArray陣列
        {
            int         pgprocno = pgprocnos[index];//allPgXact[]索引
            PGXACT     *pgxact = &allPgXact[pgprocno];//獲取PGXACT
            TransactionId xid;//事務id

/*
             * Skip over backends doing logical decoding which manages xmin
             * separately (check below) and ones running LAZY VACUUM.
             * 跳過正在執行邏輯解碼(單獨管理xmin)和執行LAZY VACUUM的程式.
             * 
             */
            if (pgxact->vacuumFlags &
                (PROC_IN_LOGICAL_DECODING | PROC_IN_VACUUM))
                continue;

/* Update globalxmin to be the smallest valid xmin */
            //更新globalxmin為最小有效的xmin
            xid = UINT32_ACCESS_ONCE(pgxact->xmin);//獲取程式事務的xmin
            if (TransactionIdIsNormal(xid) &&
                NormalTransactionIdPrecedes(xid, globalxmin))
                globalxmin = xid;

/* Fetch xid just once - see GetNewTransactionId */
            //只提取一次xid -- 檢視函式GetNewTransactionId
            xid = UINT32_ACCESS_ONCE(pgxact->xid);

/*
             * If the transaction has no XID assigned, we can skip it; it
             * won't have sub-XIDs either.  If the XID is >= xmax, we can also
             * skip it; such transactions will be treated as running anyway
             * (and any sub-XIDs will also be >= xmax).
             * 如果事務未分配XID事務號,跳過此事務.該事務也不會含有子事務.
             * 如果XID >= xmax,我們也可以跳過,這些事務可被處理為正在執行的思維.
             *   (這些事務的子事務XID也同樣會 >= xmax)
             */
            if (!TransactionIdIsNormal(xid)
                || !NormalTransactionIdPrecedes(xid, xmax))
                continue;

/*
             * We don't include our own XIDs (if any) in the snapshot, but we
             * must include them in xmin.
             * 在快照中,不會包含自己的XIDs,但必須體現在xmin中
             */
            if (NormalTransactionIdPrecedes(xid, xmin))
                //xid 小於 xmin,設定為xid
                xmin = xid;
            if (pgxact == MyPgXact)
                continue;//跳過本事務

/* Add XID to snapshot. */
            //新增XID到快照中
            snapshot->xip[count++] = xid;

/*
             * Save subtransaction XIDs if possible (if we've already
             * overflowed, there's no point).  Note that the subxact XIDs must
             * be later than their parent, so no need to check them against
             * xmin.  We could filter against xmax, but it seems better not to
             * do that much work while holding the ProcArrayLock.
             * 如可能,儲存子事務XIDs(如果已經溢位,那就沒法了).
             * 注意子事務XIDs必須在他們的父事務之後發生,因此無需檢查xmin.
             * 我們可以利用xmax進行過濾，但是在持有鎖ProcArrayLock時最好不要做那麼多的工作。
             *
             * The other backend can add more subxids concurrently, but cannot
             * remove any.  Hence it's important to fetch nxids just once.
             * Should be safe to use memcpy, though.  (We needn't worry about
             * missing any xids added concurrently, because they must postdate
             * xmax.)
             * 其他後臺程式可能併發增加子事務ID,但不能清除.
             * 因此,只取一次nxids很重要.不過,使用memcpy是安全的.
             * (不需要擔心遺漏併發增加xids,因為他們在xmax之後)
             *
             * Again, our own XIDs are not included in the snapshot.
             * 再次,我們自己的XIDs不需要包含在快照中
             */
            if (!suboverflowed)
            {
                if (pgxact->overflowed)
                    suboverflowed = true;
                else
                {
                    int         nxids = pgxact->nxids;

if (nxids > 0)
                    {
                        PGPROC     *proc = &allProcs[pgprocno];

pg_read_barrier();  /* pairs with GetNewTransactionId */

memcpy(snapshot->subxip + subcount,
                               (void *) proc->subxids.xids,
                               nxids * sizeof(TransactionId));
                        subcount += nxids;
                    }
                }
            }
        }
    }
    else
    {
        /*
         * We're in hot standby, so get XIDs from KnownAssignedXids.
         * 處於hot standby中,透過KnownAssignedXids獲取XIDs.
         *
         * We store all xids directly into subxip[]. Here's why:
         * 直接儲存所有的xids到subxip[]中,這是因為:
         *
         * In recovery we don't know which xids are top-level and which are
         * subxacts, a design choice that greatly simplifies xid processing.
         * 在恢復過程中,我們不需要知道哪些xids是頂層事務,哪些是子事務,
         * 這可以極大的簡化xid處理過程.
         * 
         * It seems like we would want to try to put xids into xip[] only, but
         * that is fairly small. We would either need to make that bigger or
         * to increase the rate at which we WAL-log xid assignment; neither is
         * an appealing choice.
         * 似乎我們只想把xid放到xip[]中，但xip陣列是相當小的。
         *   我們要麼需要擴充套件，要麼提高WAL-log xid分派的速度;
         *   但這兩個選擇都不吸引人。
         *
         * We could try to store xids into xip[] first and then into subxip[]
         * if there are too many xids. That only works if the snapshot doesn't
         * overflow because we do not search subxip[] in that case. A simpler
         * way is to just store all xids in the subxact array because this is
         * by far the bigger array. We just leave the xip array empty.
         * 如果xid太多的話,我們嘗試先將xid儲存到xip[]中，然後再在subxip[]中儲存。
         * 這隻在快照沒有溢位的情況下有效，因為在這種情況下我們不搜尋subxip[]。
         * 一種更簡單的方法是將所有xid儲存在subxact陣列中，因為這個陣列要大得多。
         * 讓xip陣列為空。
         *
         * Either way we need to change the way XidInMVCCSnapshot() works
         * depending upon when the snapshot was taken, or change normal
         * snapshot processing so it matches.
         * 無論哪種方式，我們都需要根據快照的拍攝時間更改XidInMVCCSnapshot()的工作方式，
         *   或者更改正常的快照處理，使其匹配。
         *
         * Note: It is possible for recovery to end before we finish taking
         * the snapshot, and for newly assigned transaction ids to be added to
         * the ProcArray.  xmax cannot change while we hold ProcArrayLock, so
         * those newly added transaction ids would be filtered away, so we
         * need not be concerned about them.
         * 注意:在我們完成快照之前，恢復可能會結束，
         *   並且新分配的事務id可能會新增到ProcArray中。
         * 當我們持有鎖ProcArrayLock時，xmax無法更改，
         *   因此那些新新增的事務id將被過濾掉，因此無需擔心。
         */
        subcount = KnownAssignedXidsGetAndSetXmin(snapshot->subxip, &xmin,
                                                  xmax);

if (TransactionIdPrecedesOrEquals(xmin, procArray->lastOverflowedXid))
            suboverflowed = true;
    }

/*
     * Fetch into local variable while ProcArrayLock is held - the
     * LWLockRelease below is a barrier, ensuring this happens inside the
     * lock.
     * 持有ProcArrayLock鎖時,提前到本地變數中,
     *   下面的LWLockRelease是一個屏障，確保這發生在鎖內部。
     */
    replication_slot_xmin = procArray->replication_slot_xmin;
    replication_slot_catalog_xmin = procArray->replication_slot_catalog_xmin;

if (!TransactionIdIsValid(MyPgXact->xmin))
        MyPgXact->xmin = TransactionXmin = xmin;

LWLockRelease(ProcArrayLock);

/*
     * Update globalxmin to include actual process xids.  This is a slightly
     * different way of computing it than GetOldestXmin uses, but should give
     * the same result.
     * 更新globalxmin已包含實際的程式xids.
     * 這是一種與GetOldestXmin使用的計算方法略有不同的方法，但是應該會得到相同的結果。
     */
    if (TransactionIdPrecedes(xmin, globalxmin))
        globalxmin = xmin;

/* Update global variables too */
    //更新全域性變數
    RecentGlobalXmin = globalxmin - vacuum_defer_cleanup_age;
    if (!TransactionIdIsNormal(RecentGlobalXmin))
        RecentGlobalXmin = FirstNormalTransactionId;

/* Check whether there's a replication slot requiring an older xmin. */
    //檢查是否存在正在請求更舊xmin的複製slot
    if (TransactionIdIsValid(replication_slot_xmin) &&
        NormalTransactionIdPrecedes(replication_slot_xmin, RecentGlobalXmin))
        RecentGlobalXmin = replication_slot_xmin;

/* Non-catalog tables can be vacuumed if older than this xid */
    //比該xid小的非catalog表可被vacuum程式清除
    RecentGlobalDataXmin = RecentGlobalXmin;

/*
     * Check whether there's a replication slot requiring an older catalog
     * xmin.
     * 檢查是否存在正確請求更舊catalog xmin的複製slot
     */
    if (TransactionIdIsNormal(replication_slot_catalog_xmin) &&
        NormalTransactionIdPrecedes(replication_slot_catalog_xmin, RecentGlobalXmin))
        RecentGlobalXmin = replication_slot_catalog_xmin;

RecentXmin = xmin;

snapshot->xmin = xmin;
    snapshot->xmax = xmax;
    snapshot->xcnt = count;
    snapshot->subxcnt = subcount;
    snapshot->suboverflowed = suboverflowed;
    //當前命令id
    snapshot->curcid = GetCurrentCommandId(false);

/*
     * This is a new snapshot, so set both refcounts are zero, and mark it as
     * not copied in persistent memory.
     * 這是一個新的快照,因此設定refcounts為0,並標記其未在持久化記憶體中複製.
     */
    snapshot->active_count = 0;
    snapshot->regd_count = 0;
    snapshot->copied = false;

if (old_snapshot_threshold < 0)
    {
        /*
         * If not using "snapshot too old" feature, fill related fields with
         * dummy values that don't require any locking.
         * 如啟用"snapshot too old"特性,使用虛擬值填充相關的欄位,這裡不需要鎖.
         */
        snapshot->lsn = InvalidXLogRecPtr;
        snapshot->whenTaken = 0;
    }
    else
    {
        /*
         * Capture the current time and WAL stream location in case this
         * snapshot becomes old enough to need to fall back on the special
         * "old snapshot" logic.
         * 捕獲當前時間和WAL流位置，以防快照變得足夠舊時需要使用特殊的“old snapshot”邏輯。
         */
        snapshot->lsn = GetXLogInsertRecPtr();
        snapshot->whenTaken = GetSnapshotCurrentTimestamp();
        MaintainOldSnapshotTimeMapping(snapshot->whenTaken, xmin);
    }
    //返回快照
    return snapshot;
}

```

### 三、跟蹤分析
執行簡單查詢,可觸發獲取快照邏輯.
```
16:35:08 (xdb@[local]:5432)testdb=# begin;
BEGIN
16:35:13 (xdb@[local]:5432)testdb=#* select 1;

```
啟動gdb,設定斷點
```
(gdb) b GetSnapshotData
Breakpoint 1 at 0x89aef3: file procarray.c, line 1519.
(gdb) c
Continuing.

Breakpoint 1, GetSnapshotData (snapshot=0xf9be60 <currentsnapshotdata>) at procarray.c:1519
1519        ProcArrayStruct *arrayP = procArray;
(gdb) 
```
輸入引數snapshot,實質是全域性變數CurrentSnapshotData
```
(gdb) p *snapshot
$1 = {satisfies = 0xa9310d <heaptuplesatisfiesmvcc>, xmin = 2354, xmax = 2358, xip = 0x24c7e40, xcnt = 1, 
  subxip = 0x251dfa0, subxcnt = 0, suboverflowed = false, takenDuringRecovery = false, copied = false, curcid = 0, 
  speculativeToken = 0, active_count = 0, regd_count = 0, ph_node = {first_child = 0x0, next_sibling = 0x0, 
    prev_or_parent = 0x0}, whenTaken = 0, lsn = 0}
```
檢視共享記憶體(ShmemVariableCache)中的資訊.
nextXID = 2358,下一個待分配的事務ID = 2358.
```
(gdb) p *ShmemVariableCache
$2 = {nextOid = 42605, oidCount = 8183, nextXid = 2358, oldestXid = 561, xidVacLimit = 200000561, 
  xidWarnLimit = 2136484208, xidStopLimit = 2146484208, xidWrapLimit = 2147484208, oldestXidDB = 16400, 
  oldestCommitTsXid = 0, newestCommitTsXid = 0, latestCompletedXid = 2357, oldestClogXid = 561}
(gdb) 
```
獲取全域性程式陣列procArray,賦值->arrayP.
初始化相關變數.
```
(gdb) n
1524        int         count = 0;
(gdb) n
1525        int         subcount = 0;
(gdb) 
1526        bool        suboverflowed = false;
(gdb) 
1527        volatile TransactionId replication_slot_xmin = InvalidTransactionId;
(gdb) 
1528        volatile TransactionId replication_slot_catalog_xmin = InvalidTransactionId;
(gdb) 
1530        Assert(snapshot != NULL);
(gdb) 
1543        if (snapshot->xip == NULL)
(gdb) 
```
檢視程式陣列資訊和allPgXact[]陣列編號(arrayP->pgprocnos陣列).
allPgXact定義:static PGXACT \*allPgXact;
```
(gdb) p *arrayP
$3 = {numProcs = 5, maxProcs = 112, maxKnownAssignedXids = 7280, numKnownAssignedXids = 0, tailKnownAssignedXids = 0, 
  headKnownAssignedXids = 0, known_assigned_xids_lck = 0 '\000', lastOverflowedXid = 0, replication_slot_xmin = 0, 
  replication_slot_catalog_xmin = 0, pgprocnos = 0x7f8765d9a3a8}
(gdb) p arrayP->pgprocnos[0]
$4 = 97
(gdb) p arrayP->pgprocnos[1]
$5 = 98
(gdb) p arrayP->pgprocnos[2]
$6 = 99
(gdb) p arrayP->pgprocnos[3]
$7 = 103
(gdb) p arrayP->pgprocnos[4]
$9 = 111
```
加鎖,獲取/修改相關資訊
```
(gdb) 
1568        LWLockAcquire(ProcArrayLock, LW_SHARED);
```
計算xmax
```
(gdb) n
1571        xmax = ShmemVariableCache->latestCompletedXid;
(gdb) 
1572        Assert(TransactionIdIsNormal(xmax));
(gdb) p xmax
$10 = 2357
(gdb) n
1573        TransactionIdAdvance(xmax);
(gdb) 
1576        globalxmin = xmin = xmax;
(gdb) 
1578        snapshot->takenDuringRecovery = RecoveryInProgress();
(gdb) p xmax
$11 = 2358
```
判斷是否處於恢復狀態,當前不是恢復狀態,進入相應的處理邏輯
```
(gdb) n
1580        if (!snapshot->takenDuringRecovery)
(gdb) p snapshot->takenDuringRecovery
$13 = false
(gdb) n
1582            int        *pgprocnos = arrayP->pgprocnos;
(gdb) 
```
獲取程式數和PGXACT索引陣列,準備遍歷
```
(gdb) n
1590            numProcs = arrayP->numProcs;
(gdb) 
1591            for (index = 0; index < numProcs; index++)
(gdb) 
(gdb) p *pgprocnos
$14 = 97
(gdb) p numProcs
$15 = 5
(gdb) 
```
獲取pgxact資訊
```
(gdb) n
1593                int         pgprocno = pgprocnos[index];
(gdb) 
1594                volatile PGXACT *pgxact = &allPgXact[pgprocno];
(gdb) 
1601                if (pgxact->vacuumFlags & PROC_IN_LOGICAL_DECODING)
(gdb) 
1605                if (pgxact->vacuumFlags & PROC_IN_VACUUM)
(gdb) 
1609                xid = pgxact->xmin; /* fetch just once */
(gdb) p *pgxact
$16 = {xid = 0, xmin = 0, vacuumFlags = 0 '\000', overflowed = false, delayChkpt = false, nxids = 0 '\000'}
(gdb) 
```
不是正常的xid,下一個pgxact
```
(gdb) n
1610                if (TransactionIdIsNormal(xid) &&
(gdb) 
1615                xid = pgxact->xid;
(gdb) 
1623                if (!TransactionIdIsNormal(xid)
(gdb) p xid
$17 = 0
(gdb) n
1625                    continue;
(gdb) 
```
下一個xid = 2355,正常的事務ID
```
(gdb) 
1591            for (index = 0; index < numProcs; index++)
(gdb) 
1593                int         pgprocno = pgprocnos[index];
(gdb) 
1594                volatile PGXACT *pgxact = &allPgXact[pgprocno];
(gdb) 
1601                if (pgxact->vacuumFlags & PROC_IN_LOGICAL_DECODING)
(gdb) p *pgxact
$18 = {xid = 2355, xmin = 0, vacuumFlags = 0 '\000', overflowed = false, delayChkpt = false, nxids = 0 '\000'}
(gdb) 
```
進行處理
```
(gdb) n
1605                if (pgxact->vacuumFlags & PROC_IN_VACUUM)
(gdb) 
1609                xid = pgxact->xmin; /* fetch just once */
(gdb) 
1610                if (TransactionIdIsNormal(xid) &&
(gdb) 
1615                xid = pgxact->xid;
(gdb) 
1623                if (!TransactionIdIsNormal(xid)
(gdb) 
1624                    || !NormalTransactionIdPrecedes(xid, xmax))
(gdb) 
1631                if (NormalTransactionIdPrecedes(xid, xmin))
(gdb) p xid
$19 = 2355
(gdb) p xmin
$20 = 2358
(gdb) n
1632                    xmin = xid;
(gdb) 
1633                if (pgxact == MyPgXact)
(gdb) 
```
這是同一個xact,處理下一個xact
```
(gdb) 
1633                if (pgxact == MyPgXact)
(gdb) p pgxact
$21 = (volatile PGXACT *) 0x7f8765d9a218
(gdb) p MyPgXact
$22 = (struct PGXACT *) 0x7f8765d9a218
(gdb) n
1634                    continue;
(gdb) 
```
下一個是2354
```
...
(gdb) p *pgxact
$23 = {xid = 2354, xmin = 0, vacuumFlags = 0 '\000', overflowed = false, delayChkpt = false, nxids = 0 '\000'}
(gdb) 
```
xmin調整為2354
```
1631                if (NormalTransactionIdPrecedes(xid, xmin))
(gdb) 
1632                    xmin = xid;
(gdb) 
1633                if (pgxact == MyPgXact)
(gdb) p xmin
$24 = 2354
(gdb) 
```
寫入到xip_list中
```
1637                snapshot->xip[count++] = xid;
(gdb) 
1654                if (!suboverflowed)
(gdb) 
(gdb) p count
$25 = 1
```
繼續迴圈,完成5個pgxact的遍歷
```
1591            for (index = 0; index < numProcs; index++)
(gdb) 
1715        replication_slot_xmin = procArray->replication_slot_xmin;
(gdb) 
```
無複製資訊
```
(gdb) 
1715        replication_slot_xmin = procArray->replication_slot_xmin;
(gdb) p procArray->replication_slot_xmin
$28 = 0
(gdb) n
1716        replication_slot_catalog_xmin = procArray->replication_slot_catalog_xmin;
(gdb) 
1718        if (!TransactionIdIsValid(MyPgXact->xmin))
```
調整本程式的事務資訊
```
(gdb) n
1719            MyPgXact->xmin = TransactionXmin = xmin;
(gdb) p MyPgXact->xmin
$29 = 0
(gdb) n
```
釋放鎖
```
1721        LWLockRelease(ProcArrayLock);
(gdb) 
1728        if (TransactionIdPrecedes(xmin, globalxmin))
(gdb) 
```
調整全域性xmin
```
(gdb) p xmin
$30 = 2354
(gdb) p globalxmin
$31 = 2358
(gdb) n
1729            globalxmin = xmin;
(gdb) 
```
更新其他資訊
```
(gdb) 
1732        RecentGlobalXmin = globalxmin - vacuum_defer_cleanup_age;
(gdb) p RecentGlobalXmin
$32 = 2354
(gdb) p vacuum_defer_cleanup_age
$33 = 0
(gdb) n
1733        if (!TransactionIdIsNormal(RecentGlobalXmin))
(gdb) 
1737        if (TransactionIdIsValid(replication_slot_xmin) &&
(gdb) 
1742        RecentGlobalDataXmin = RecentGlobalXmin;
(gdb) p RecentGlobalXmin
$34 = 2354
(gdb) n
1748        if (TransactionIdIsNormal(replication_slot_catalog_xmin) &&
(gdb) 
```
填充snapshot域欄位資訊
```
(gdb) 
1752        RecentXmin = xmin;
(gdb) 
1754        snapshot->xmin = xmin;
(gdb) 
1755        snapshot->xmax = xmax;
(gdb) 
1756        snapshot->xcnt = count;
(gdb) 
1757        snapshot->subxcnt = subcount;
(gdb) 
1758        snapshot->suboverflowed = suboverflowed;
(gdb) 
1760        snapshot->curcid = GetCurrentCommandId(false);
(gdb) 
1766        snapshot->active_count = 0;
(gdb) 
1767        snapshot->regd_count = 0;
(gdb) 
1768        snapshot->copied = false;
(gdb) 
1770        if (old_snapshot_threshold < 0)
(gdb) 
1776            snapshot->lsn = InvalidXLogRecPtr;
(gdb) 
1777            snapshot->whenTaken = 0;
(gdb) 
1791        return snapshot;
(gdb) 
```
返回snapshot
```
(gdb) p snapshot
$35 = (Snapshot) 0xf9be60 <currentsnapshotdata>
(gdb) p *snapshot
$36 = {satisfies = 0xa9310d <heaptuplesatisfiesmvcc>, xmin = 2354, xmax = 2358, xip = 0x24c7e40, xcnt = 1, 
  subxip = 0x251dfa0, subxcnt = 0, suboverflowed = false, takenDuringRecovery = false, copied = false, curcid = 0, 
  speculativeToken = 0, active_count = 0, regd_count = 0, ph_node = {first_child = 0x0, next_sibling = 0x0, 
    prev_or_parent = 0x0}, whenTaken = 0, lsn = 0}
(gdb) 
```
注意:snapshot->satisfies函式在初始化該全域性變數已設定為HeapTupleSatisfiesMVCC.

DONE!

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

PostgreSQL 原始碼解讀（117）- MVCC#2(獲取快照#2)

相關文章