-- 查看默认事务隔离级别
show default_transaction_isolation;
 default_transaction_isolation
-------------------------------
 read committed

-- 查询当前的事务快照 pg 10
SELECT txid_current_snapshot();
 txid_current_snapshot
-----------------------
 1081:1081:

-- 查询所有正在活跃的进程
SELECT  * FROM pg_stat_activity;

--

# 1 生成事务快照
GetTransactionSnapshot

heap_insert
    GetCurrentTransactionId  # 申请事务id
heap_delete
    GetCurrentTransactionId
    HeapTupleSatisfiesUpdate # 查询提交日志
heap_update
    GetCurrentTransactionId
    HeapTupleSatisfiesUpdate # 查询提交日志
heapgettup
    HeapTupleSatisfiesVisibility  # 查询事务快照
        HeapTupleSatisfiesMVCC

tuple
    xmin = xid
    xmax = 0
    cid = cid
    infomask = HEAP_XMAX_INVALID

tuple
    cid = cid
    xmax = xid

# 阶段一、获取tup状态，先检查tup是否被成功修改
# 如果tup未被成功修改，阶段二再检查本事务是否可见tup
if tup.xmin = my.xid:
    if tup.cid >= my.cid:
        return HeapTupleInvisible
    else:
        if tup.xmin != my.xid
            return HeapTupleMayBeUpdated
        else:
            if tup.cid >= my.cid: # related to scan, remain, not understand
                return HeapTupleSelfUpdated
            else:
                return HeapTupleInvisible
else:
    if tup.xmin.stat = uncommit: # check all process
        return HeapTupleInvisible
    elif tup.xmin.stat = commit: # check commit log
        if tup.xmax = my.xid:
            if tup.cid >= my.cid:
                return HeapTupleSelfUpdated
            else:
                return HeapTupleInvisible
        else:
            if tup.xmax.stat = uncommit:
                return HeapTupleBeingUpdated
            else:
                if tup.xmax.stat = rollback:
                    return HeapTupleMayBeUpdated # tup未被修改，无事务修改tup，或修改的事务已回滚
                else: # tup.xmax.stat = commit
                    return HeapTupleUpdated # tup被修改，修改事务已提交
    else tup.xmin.stat = rollback:
        return HeapTupleInvisible

# 阶段二，根据tup状态，如果tup未被成功修改，
if tup.stat = HeapTupleInvisible:
    error
elif tup.stat = HeapTupleBeingUpdated:
    if tup.xmax != my.xid:
        XactLockTableWait 等锁释放
        if tup.infomask = HEAP_XMAX_INVALID:
            tup.stat = HeapTupleMayBeUpdated
        else:
            tup.stat = HeapTupleUpdated
    else:
        if tup.infomask = HEAP_XMAX_INVALID:
            tup.stat = HeapTupleMayBeUpdated
        else:
            tup.stat = HeapTupleUpdated
if tup.stat = HeapTupleMayBeUpdated:
    if ! check visibility tup, snapshot:
        tup.stat = HeapTupleUpdated
if tup.stat != HeapTupleMayBeUpdated:
    return
tup.cmax = my.xid

HeapTupleSatisfiesUpdate
    # 阶段一、检查Tuple的写入事务
    if  !HeapTupleHeaderXminCommitted(tuple): # （快速判断）not tuple->infomask & HEAP_XMIN_COMMITTED
        if HeapTupleHeaderXminInvalid: # tuple->infomask & [HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID] = HEAP_XMIN_INVALID
                return HeapTupleInvisible
        if TransactionIdIsCurrentTransactionId(tuple->xmin): # Tuple->xmin 的写入事务 是 本事务
            if tuple->cid >= curcid: # 根据cid判断可见性
                return HeapTupleInvisible
            # 省略，看不懂
        elif TransactionIdIsInProgress(tuple->xmin): # Tuple的写入事务 未提交
            return HeapTupleInvisible
        elif TransactionIdDidCommit(tuple->xmin): #  Tuple的写入事务 已提交（慢速判断，查询事务日志）
            tuple->infomask & HEAP_XMIN_COMMITTED
        else:
            tuple->infomask & HEAP_XMIN_INVALID  # 未找到Tuple的写入事务的提交日志
            return HeapTupleInvisible
    else:   # Tuple的写入事务 已提交
        # 阶段二、检查Tuple的删除事务
        if tuple->t_infomask & HEAP_XMAX_INVALID: # 初始状态，并没有事务尝试删除Tuple，INSERT时，t_infomask初始值为HEAP_XMAX_INVALID
            return HeapTupleMayBeUpdated
        else:
            if tuple->t_infomask & HEAP_XMAX_COMMITTED：  # （快速判断）Tuple的删除事务，已提交
                return HeapTupleUpdated
            if tuple->t_infomask & HEAP_XMAX_IS_MULTI # 暂时忽略
                ...

            if TransactionIdIsCurrentTransactionId(tuple->xmax): # Tuple的删除事务，是本事务
                if tuple->cid >= curcid:
                    return HeapTupleSelfUpdated # 自己未来删除？
                else:
                    return HeapTupleInvisible
            else;
                if TransactionIdIsInProgress(tuple->xmax): # Tuple的删除事务，未提交，（遍历所有正在运行中的线程，判断事务状态）
                    return HeapTupleBeingUpdated
                else: # 删除Tuple的事务，已提交或发生异常
                    if not TransactionIdDidCommit(tuple->xmax)：# Tuple的删除事务，未提交（遍历事务提交日志）
                        tuple->infomask & HEAP_XMAX_INVALID # 删除Tuple的事务，发生异常了
                        return HeapTupleMayBeUpdated
                    else:   # Tuple的删除事务，已提交
                        tuple->infomask & HEAP_XMAX_COMMITTED
                        return HeapTupleUpdated

exec_simple_query
    # 1. 简单的初始化
    start_xact_command

    # 2. 对于INSERT/SELECT/UPDATE/DELETE语句，在语义分析之前，都会调用一次GetTransactionSnapshot，来生成一次快照
    #    此处的快照，用于语义分析、计划初始化
    if analyze_requires_snapshot
        GetTransactionSnapshot
    pg_analyze_and_rewrite
    pg_plan_queries
    PortalStart
    PortalRun
        if PORTAL_MULTI_QUERY:
            PortalRunMulti
                # 3. 对于INSERT/DELETE/UPDATE等语法，重新获取最新快照
                GetTransactionSnapshot
                ProcessQuery
                    ExecutorRun
                        ExecutePlan
                            ExecProcNode
                                ExecModifyTable
                                    ExecInsert
                                        # 4. 调用存储统一接口
                                        heap_insert
                                            GetCurrentTransactionId # 5. 获取当前事务的id
                                            heap_prepare_insert     # 6. 将事务id写入Tuple
                                            ...                     # 7. 继续其他heap_insert操作

exec_simple_query
    # 1. 简单的初始化
    start_xact_command

    # 2. 对于INSERT/SELECT/UPDATE/DELETE语句，在语义分析之前，都会调用一次GetTransactionSnapshot，来生成一次快照
    #    此处的快照，用于语义分析、计划初始化
    if analyze_requires_snapshot
        GetTransactionSnapshot
    pg_analyze_and_rewrite
    pg_plan_queries
    PortalStart
    PortalRun
        if PORTAL_MULTI_QUERY:
            PortalRunMulti
                # 3. 对于INSERT/DELETE/UPDATE等语法，重新获取最新快照
                GetTransactionSnapshot
                ProcessQuery
                    ExecutorRun
                        ExecutePlan
                            ExecProcNode
                                ExecModifyTable
                                    ExecDelete
                                        # 4. 调用存储统一接口
                                        heap_delete
                                            GetCurrentTransactionId # 5. 获取当前事务的id
                                            # 6 根据提交日志，检查事务可见性
                                            HeapTupleSatisfiesUpdate

exec_simple_query
    # 1. 简单的初始化
    start_xact_command

    # 2. 对于INSERT/SELECT/UPDATE/DELETE语句，在语义分析之前，都会调用一次GetTransactionSnapshot，来生成一次快照
    #    此处的快照，用于语义分析、计划初始化
    if analyze_requires_snapshot
        GetTransactionSnapshot
    pg_analyze_and_rewrite
    pg_plan_queries
    PortalStart
    PortalRun
        if PORTAL_MULTI_QUERY:
            PortalRunMulti
                # 3. 对于INSERT/DELETE/UPDATE等语法，重新获取最新快照
                GetTransactionSnapshot
                ProcessQuery
                    ExecutorRun
                        ExecutePlan
                            ExecProcNode
                                ExecModifyTable
                                    ExecUpdate
                                        # 4. 调用存储统一接口
                                        heap_update
                                            GetCurrentTransactionId # 5. 获取当前事务的id

exec_simple_query
    # 1. 简单的初始化
    start_xact_command

    # 2. 对于INSERT/SELECT/UPDATE/DELETE语句，在语义分析之前，都会调用一次GetTransactionSnapshot，来生成一次快照
    #    此处的快照，用于语义分析、计划初始化
    if analyze_requires_snapshot
        GetTransactionSnapshot
    pg_analyze_and_rewrite
    pg_plan_queries

    # 3. 获取快照
    PortalStart
        GetTransactionSnapshot
    PortalRun
        if PORTAL_ONE_SELECT:
            PortalRunSelect
                ExecutorRun
                    standard_ExecutorRun
                        ExecutePlan
                            ExecProcNode
                                ExecSeqScan
                                    SeqNext
                                        # 3. 在heapam层，使用快照
                                        heap_getnext
                                            heapgettup
                                                HeapTupleSatisfiesVisibility
                                                    HeapTupleSatisfiesMVCC
                                                        if !HeapTupleHeaderXminCommitted:
                                                            XidInMVCCSnapshot(HeapTupleHeaderGetRawXmin(tuple), HeapScanDesc->rs_snapshot)
                                                                # tuple 不可见

SELECT txid_current_snapshot();

GetSnapshotData
    snapshot->xmax = ShmemVariableCache->latestCompletedXid
    for idx in procArray: # 遍历 allPgXact，获取所有xid
        pgprocno = procArray[idx]
        PGXACT *pgxact = &allPgXact[pgprocno]
        xid = pgxact->xid
        snapshot->xip[count++] = xid
        xin = MIN(xid, xin)
    snapshot->xcnt = count
    snapshot->xin = xin

typedef struct { /* ignore Union */
    TransactionId t_xmin; /* 生成tuple的事务ID */
    TransactionId t_xmax; /* 删除tuple的事务ID，默认为0 */
    CommandId	t_cid;
    ItemPointerData t_ctid; /* 更新tuple时，新数据的事务ID，默认为0 */

    uint16 t_infomask2;
    uint16 t_infomask;
    uint8 t_hoff;
    bits8 t_bits[FLEXIBLE_ARRAY_MEMBER];

    /* tuple data */
} HeapTupleHeader;

heap_insert(rel, tup, cid) # CommandId
    xid = get_cur_trans_id()

    heap_prepare_insert(rel, tup, xid, cid)
        heap_tup_set_xmin(tup, xid)
        heap_tup_set_cmin(tup, cid)

    buf = rel_get_buf_for_tup(rel, tup.len)
        blkno = get_page_with_free_space(rel, tlen)
            fsm_search(rel, tlen)
                fsm_search_avail(rel, tlen)
        read_buffer_bi(rel, blkno)
            read_buf(rel, blkno)
                read_buf_extend(rel, blkno)
                    read_buf_comm(rel, blkno)
                        bufhdr = buf_alloc(rel, blkno)
                        lwlock_acquire(bufhdr, LW_EXCLUSIVE)
        visibilitymap_pin(rel, vmbuf)
            vm_readbuf()
                vm_extend()
                read_buf_extend()
        lock_buffer(BUFFER_LOCK_EXCLUSIVE)
        ...

        needlock = not rel_is_local(rel)
        if needlock:
            LockRelationForExtension(rel, ExclusiveLock)
                LockAcquire(rel, ExclusiveLock)
                    LockAcquireExtended(rel, ExclusiveLock)

LockAcquireExtended(relid, mode)
    locallock = hash_search(LockMethodLocalHash, relid, enter)

typedef struct {
    LOCKTAG tag;
    SHM_QUEUE proLocks; /* 持有锁的进程：PROCLOCK  */
    PROC_QUEUE waitProcs; /* PGPROC */

    int granted[MAX_LOCKMODES]; /* 锁上加锁次数，会同时持有多种锁 */
} LOCK;

typedef struct {
    PROCLOCKTAG tag;
    PGPROC *groupLeader;
    SHM_QUEUE lockLink; /* LOCK */
    SHM_QUEUE proLink; /* PGPROC */
} PROCLOCK;

typedef struct {
    LOCALLOCKTAG tag;

    LOCK lock;
    PROCLOCK *proclock;
    int64 nLocks; /* 持有锁数量 */

} LOCALLOCK;

- heap_open(relid lockmode) # not index
- relation_open(relid, lockmode) # any rel
    LockRelationOid(relid, lockmode)
        LockAcquire(tag, lockmode)
    RelationIdGetRelation(relid)
        if RelationIdCacheLookup(relationId, rd) -> hash_search(RelationIdCache)
            RelationIncrementReferenceCount(rel)
        else RelationBuildDesc(relid)
            RelationIncrementReferenceCount(rel)
- heap_close(relid, lockmode)
- relation_close(rel, lockmode)
    RelationClose(rel)
        RelationDecrementReferenceCount()
        UnlockRelationId(lockmode)

heap_insert(rel, tup, cid)
    xid = GetCurrentTransactionId()
    tup = heap_prepare_insert() # set [ insert xid | delete xid | cmd id | ... ]
    buf = RelationGetBufferForTuple(rel, tup.len)
        LockRelationForExtension(rel, ExclusiveLock)
        ReadBuffer(rel, blkno) # LWLockAcquire(bufhdr, LW_EXCLUSIVE), LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE)
        UnlockRelationForExtension(rel, ExclusiveLock)
    RelationPutHeapTuple(rel, buf, tup) # PageAddItem
    /* xlog */
    UnlockReleaseBuffer(buf)
        LockBuffer(buf, BUFFER_LOCK_UNLOCK)
        ReleaseBuffer(buf)
heap_delete(rel, tid, cid, snapshot)
    xid = GetCurrentTransactionId()
    buf = ReadBuffer(rel, ItemPointerGetBlockNumber(tid))
    LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE)
    ... 复杂
    heap_acquire_tuplock(rel, tup, LockTupleExclusive, LockWaitBlock)
    ...
    UnlockTupleTuplock(rel, tup, LockTupleExclusive)
heap_update(rel, okdtid, newtup, cid, snapshot, lockmode)

relation锁：

buffer锁： call LWLockAcquire(LW_SHARED / LW_EXCLUSIVE)
#define BUFFER_LOCK_UNLOCK		0
#define BUFFER_LOCK_SHARE		1
#define BUFFER_LOCK_EXCLUSIVE	2

tuple锁：
typedef enum {
    LockTupleKeyShare, /* SELECT FOR KEY SHARE */
    LockTupleShare, /* SELECT FOR SHARE */
    LockTupleNoKeyExclusive, /* SELECT FOR NO KEY UPDATE, and UPDATEs that don't modify key columns */
    LockTupleExclusive, /* SELECT FOR UPDATE, UPDATEs that modify key columns, and DELETE */
} LockTupleMode; 映射到reguler锁 LockMode
{
    {AccessShareLock, MultiXactStatusForKeyShare, -1},
    {RowShareLock, MultiXactStatusForShare, -1},
    {ExclusiveLock, MultiXactStatusForNoKeyUpdate, MultiXactStatusNoKeyUpdate,},
    {AccessExclusiveLock, MultiXactStatusForUpdate, MultiXactStatusUpdate}
}

LockTupleTuplock(rel, tid, lockmode)
    LockTuple(rel, tup, tupleLockExtraInfo[lockmode])
        LockAcquire(tag, lockmode)

typedef enum
{
	MultiXactStatusForKeyShare = 0x00,
	MultiXactStatusForShare = 0x01,
	MultiXactStatusForNoKeyUpdate = 0x02,
	MultiXactStatusForUpdate = 0x03,
	/* an update that doesn't touch "key" columns */
	MultiXactStatusNoKeyUpdate = 0x04,
	/* other updates, and delete */
	MultiXactStatusUpdate = 0x05
} MultiXactStatus;