typedef struct HeapTupleHeaderData {
    union {
        HeapTupleFields t_heap; /* 存储该元组的一些描述信息 */
        DatumTupleFields t_datum;
    } t_choice;

    ItemPointerData t_ctid; /* (块号，块内偏移) 存储用来记录当前元组或新元组的物理位置 */

    /* Fields below here must match MinimalTupleData! */

    uint16 t_infomask2;

    uint16 t_infomask; /* various flag bits, see below */

    uint8 t_hoff;

    /* ^ - 23 bytes - ^ */

    bits8 t_bits[FLEXIBLE_ARRAY_MEMBER];

    /* MORE DATA FOLLOWS AT END OF STRUCT */
} HeapTupleHeaderData;
typedef HeapTupleHeaderData* HeapTupleHeader

typedef struct HeapTupleFields {
    ShortTransactionId t_xmin; /* 存放插入该 Tuple 时的 txid */
    ShortTransactionId t_xmax; /* 存放删除或者更新该 Tuple 时的 txid，如果还没更新或者删除，那么置 0，表示无效 */

    union {
        CommandId t_cid;           /* 创建或更新/删除该 Tuple 的命令在该事务内执行的所有 SQL 命令中的编号 */
        ShortTransactionId t_xvac; /* old-style VACUUM FULL xact ID */
    } t_field3;
} HeapTupleFields;

#define HEAP_HASNULL 0x0001          /* has null attribute(s) */
#define HEAP_HASVARWIDTH 0x0002      /* has variable-width attribute(s) */
#define HEAP_HASEXTERNAL 0x0004      /* has external stored attribute(s) */
#define HEAP_HASOID 0x0008           /* has an object-id field */
#define HEAP_COMPRESSED 0x0010       /* has compressed data */
#define HEAP_COMBOCID 0x0020         /* t_cid is a combo cid */
#define HEAP_XMAX_EXCL_LOCK 0x0040   /* xmax is exclusive locker */
#define HEAP_XMAX_SHARED_LOCK 0x0080 /* xmax is shared locker */
/* if either LOCK bit is set, xmax hasn't deleted the tuple, only locked it */
#define HEAP_IS_LOCKED (HEAP_XMAX_EXCL_LOCK | HEAP_XMAX_SHARED_LOCK)
#define HEAP_XMIN_COMMITTED 0x0100 /* t_xmin committed */
#define HEAP_XMIN_INVALID 0x0200   /* t_xmin invalid/aborted */
#define HEAP_XMIN_FROZEN (HEAP_XMIN_INVALID | HEAP_XMIN_COMMITTED)
#define HEAP_XMAX_COMMITTED 0x0400 /* t_xmax committed */
#define HEAP_XMAX_INVALID 0x0800   /* t_xmax invalid/aborted */
...

#define COMMITSEQNO_INPROGRESS UINT64CONST(0x0) // 表示该事务还未提交或回滚
#define COMMITSEQNO_ABORTED UINT64CONST(0x1) // 表示该事务已经回滚
#define COMMITSEQNO_FROZEN UINT64CONST(0x2) // 表示该事务已提交，且对任何快照可见
#define COMMITSEQNO_FIRST_NORMAL UINT64CONST(0x3) // 事务正常的CSN号起始值
#define COMMITSEQNO_COMMIT_INPROGRESS (UINT64CONST(1) << 62) // 事务正在提交中

typedef struct SnapshotData {
    SnapshotSatisfiesFunc satisfies;  /* 判断可见性的函数；通常使用MVCC，即HeapTupleSatisfiesMVCC */
    TransactionId xmin; /*当前活跃事务最小值，小于该值的事务说明已结束  */
    TransactionId xmax; /*最新提交事务id（latestCompeleteXid）+1，大于等于改值说明事务还未开始，该事务id不可见  */
    TransactionId* xip; /*记录当前活跃事务链表，在CSN版本中该值无用  */
    TransactionId* subxip; /* 记录缓存子事务活跃链表，在CSN版本中该值无用  */
    uint32 xcnt; /* 记录活跃事务的个数（xip中元组数）在CSN版本中该值无用  */
    ...

    CommitSeqNo snapshotcsn; /* 快照的CSN号，一般为最新提交事务的CSN号+1(NextCommitSeqNo)，CSN号严格小于该值的事务可见。  */
    ...

    CommandId curcid; /*事务块中的命令序列号，即同一事务中，前面插入的数据，后面可见。  */
    uint32 active_count; /* ActiveSnapshot stack的refcount */
    uint32 regd_count;   /* RegisteredSnapshotList 的refcount*/
    void* user_data;     /* 本地多版本快照使用，标记该快照还有线程使用，不能直接释放 */
    SnapshotType snapshot_type; /*  openGauss单机无用  */
} SnapshotData;

bool XidVisibleInSnapshot(TransactionId xid, Snapshot snapshot, TransactionIdStatus* hintstatus, Buffer buffer, bool* sync)
{
    bool looped = false;
    *hintstatus = XID_INPROGRESS;
    if (GTM_MODE && TransactionIdFollowsOrEquals(xid, snapshot->xmax)) {
    	return false;
    }
loop:
    csn = TransactionIdGetCommitSeqNo(xid, false, true, false);
    if (COMMITSEQNO_IS_COMMITTED(csn)) {
        *hintstatus = XID_COMMITTED;
        if (csn < snapshot->snapshotcsn)
            return true;
        else
            return false;
    } else if (COMMITSEQNO_IS_COMMITTING(csn)) {
        ...
    } else {
        if (csn == COMMITSEQNO_ABORTED)
            *hintstatus = XID_ABORTED;
        return false;
    }
}

if (looped) {
    ereport(DEBUG1, (errmsg("transaction id %lu's csn %ld is changed to ABORT after lockwait.", xid, csn)));
    RecheckXidFinish(xid, csn);
    CSNLogSetCommitSeqNo(xid, 0, NULL, COMMITSEQNO_ABORTED);
    SetLatestFetchState(xid, COMMITSEQNO_ABORTED);
    *hintstatus = XID_ABORTED;
    return false;
} else {
    if (!COMMITSEQNO_IS_SUBTRANS(csn)) {
        ...
        CommitSeqNo latestCSN = GET_COMMITSEQNO(csn);
        if (latestCSN >= snapshot->snapshotcsn) {
            ...
            return false;
        }
    } else {
        parentXid = (TransactionId)GET_PARENTXID(csn);
    }
    ...
    if (TransactionIdIsValid(parentXid))
        SyncWaitXidEnd(parentXid, buffer);
    else
        SyncWaitXidEnd(xid, buffer);
    looped = true;
    parentXid = InvalidTransactionId;
    goto loop;
}

static bool HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot, Buffer buffer)
{
    // 取元组头
    HeapTupleHeader tuple = htup->t_data;
    ...
    // 根据hint bit，若xmin没有被标记为已提交：可能被标记为回滚，或者还未标记
    if (!HeapTupleHeaderXminCommitted(tuple)) {
        // 如果xmin已经被标记为invalid，说明插入该元组的事务已经回滚，直接返回不可见
        if (HeapTupleHeaderXminInvalid(tuple))
            return false;
        // xmin还未标记，并且xmin为当前事务，说明是在同一个事务内的插入命令和扫描命令，则需要去判断CID
        // 同一个事务内，后面的查询可以查到当前事务之前命令插入的并且未删除的结果
        if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(page, tuple))) {
            if ((tuple->t_infomask & HEAP_COMBOCID) && CheckStreamCombocid(tuple, snapshot->curcid, page))
                return true; /* delete after stream producer thread scan started */

            // 当前扫描命令之后的某条命令才插入
            if (HeapTupleHeaderGetCmin(tuple, page) >= snapshot->curcid)
                return false; /* inserted after scan started */
            // 到这里说明当前扫描命令之前已经插入
            // 根据hint bit，xmax被标记为invalid
            if (tuple->t_infomask & HEAP_XMAX_INVALID)
                return true;

            ...

            // 当前扫描命令之后的某条命令删除了该元组
            if (HeapTupleHeaderGetCmax(tuple, page) >= snapshot->curcid)
                return true; /* deleted after scan started */
            else
                return false; /* deleted before scan started */
        }
        // xmin还没打标记，并且不是当前事务
        else {
            // 通过csnlog判断事务是否可见，并且返回该事务的最终提交状态
            visible = XidVisibleInSnapshot(HeapTupleHeaderGetXmin(page, tuple), snapshot, &hintstatus, buffer, NULL);
            // 如果该事务提交，则打上提交的hint bit用于加速判断
            if (hintstatus == XID_COMMITTED)
                SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED, HeapTupleHeaderGetXmin(page, tuple));
            // 如果事务回滚，则打上回滚标记
            if (hintstatus == XID_ABORTED) {
                ...
                SetHintBits(tuple, buffer, HEAP_XMIN_INVALID, InvalidTransactionId);
            }
            // 如果xmin不可见，则该元组不可见
            if (!visible) {
                ...
                return false;
            }
        }
    }
    // 根据hint bit，若xmin已经被标记为已提交，则通过函数接口CommittedXidVisibleInSnapshot判断是否对本次快照可见
    else {
        /* xmin is committed, but maybe not according to our snapshot */
        if (!HeapTupleHeaderXminFrozen(tuple) &&
            !CommittedXidVisibleInSnapshot(HeapTupleHeaderGetXmin(page, tuple), snapshot, buffer)) {
            if (...) {
                return false; /* treat as still in progress */
            }
        }
    }
	// 到此为止认为xmin visible，继续判断xmax的可见性

recheck_xmax:
    // 根据hint bit，xmax已经被标记为invalid，即已经回滚
    if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid or aborted */
        return true;

    ... // 还有一些其他状态判断

    // 根据hint bit，xmax没有被标记为commited
    if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED)) {
        bool sync = false;
        TransactionId xmax = HeapTupleHeaderGetXmax(page, tuple);

        // 如果xmax为当前事务
        if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmax(page, tuple))) {
            // 如果删除该元组的命令后发生于快照扫描时刻
            if (HeapTupleHeaderGetCmax(tuple, page) >= snapshot->curcid)
                return true; /* deleted after scan started */
            else
                return false; /* deleted before scan started */
        }

        visible = XidVisibleInSnapshot(HeapTupleHeaderGetXmax(page, tuple), snapshot, &hintstatus, buffer, &sync);
        /*
         * If sync wait, xmax may be modified by others. So we need to check xmax again after acquiring the page lock.
         */
        if (sync && (xmax != HeapTupleHeaderGetXmax(page, tuple))) {
            goto recheck_xmax;
        }
        // 根据hintstatus在元组头部打标记 hint bit
        if (hintstatus == XID_COMMITTED) {
            SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED, HeapTupleHeaderGetXmax(page, tuple));
        }
        if (hintstatus == XID_ABORTED) {
            ...
            SetHintBits(tuple, buffer, HEAP_XMAX_INVALID, InvalidTransactionId);
        }
        if (!visible) {
            if (...) {
                if (sync && (xmax != HeapTupleHeaderGetXmax(page, tuple))) {
                    goto recheck_xmax;
                }
                return true; /* treat as still in progress */
            }
        }
    }
    // 根据hint bit，xmax被标记为commited
    else {
        /* xmax is committed, but maybe not according to our snapshot */
        if (!CommittedXidVisibleInSnapshot(HeapTupleHeaderGetXmax(page, tuple), snapshot, buffer)) {
            if (...) {
                return true; /* treat as still in progress */
            }
        }
    }
    return false;
}