1
// InnoDB 行的隐藏列
2
struct RowHiddenColumns {
3
    trx_id_t   DB_TRX_ID;     // 6 字节：最后修改该行的事务 ID
4
    roll_ptr_t DB_ROLL_PTR;   // 7 字节：指向 Undo Log 的回滚指针
5
    trx_id_t   DB_ROW_ID;     // 6 字节：行 ID（无主键时自动生成）
6
};
7

8
// 版本链：
9
// 当前行 → Undo Log 记录 1 → Undo Log 记录 2 → ...
10
// 通过 DB_ROLL_PTR 串联

1
# InnoDB MVCC 可见性判断
2
def is_visible(row, read_view):
3
    """判断行版本对当前事务是否可见"""
4
    trx_id = row.DB_TRX_ID
5

6
    # Read View 包含：
7
    # m_ids:       创建 Read View 时的活跃事务列表
8
    # m_up_limit_id: 活跃事务的最小 ID
9
    # m_low_limit_id: 下一个分配的事务 ID
10

11
    # 规则 1：事务 ID < m_up_limit_id
12
    # 事务在 Read View 创建前已提交，可见
13
    if trx_id < read_view.m_up_limit_id:
14
        return True
15

16
    # 规则 2：事务 ID >= m_low_limit_id
17
    # 事务在 Read View 创建后才开始，不可见
18
    if trx_id >= read_view.m_low_limit_id:
19
        return False
20

21
    # 规则 3：事务 ID 在 m_ids 中
22
    # 事务在 Read View 创建时仍活跃，不可见
23
    if trx_id in read_view.m_ids:
24
        return False
25

26
    # 规则 4：事务 ID 不在 m_ids 中
27
    # 事务在 Read View 创建时已提交，可见
28
    return True
29

30
# 读取流程
31
def mvcc_read(row, read_view):
32
    """MVCC 读取"""
33
    # 沿版本链查找可见版本
34
    current = row
35
    while current is not None:
36
        if is_visible(current, read_view):
37
            return current  # 找到可见版本
38
        # 不可见，沿 Undo Log 链查找旧版本
39
        current = follow_roll_ptr(current.DB_ROLL_PTR)
40

41
    return None  # 行对所有快照都不可见（已被删除）

1
// InnoDB Undo Log 结构
2
struct RollbackSegment {
3
    trx_id_t    trx_id;         // 事务 ID
4
    page_no_t   space_id;       // 表空间 ID
5
    page_no_t   page_no;        // 回滚段首页号
6
    uint32_t    max_size;       // 最大页数
7
    uint32_t    curr_size;      // 当前页数
8
    UndoSlot    slots[1024];    // Undo Log 槽位数组
9
};
10

11
// 每个 Undo Log Slot 指向一个 Undo Log 链表
12
// Insert Undo Log: 记录 INSERT 操作的回滚信息，事务提交后即可清理
13
// Update Undo Log: 记录 UPDATE/DELETE 操作的回滚信息，需等待所有快照不再引用

1
# InnoDB Purge 线程工作流程
2
def purge_thread_main():
3
    while True:
4
        # 1. 找到最老的活跃 Read View
5
        oldest_view = get_oldest_read_view()
6

7
        # 2. 清理该 Read View 之前的 Undo Log
8
        for undo_log in get_expired_undo_logs(oldest_view):
9
            # 清理 Update Undo Log（Insert Undo 已在提交时清理）
10
            free_undo_log(undo_log)
11

12
        # 3. 清理标记删除的索引记录
13
        for marked_delete_record in get_purge_records(oldest_view):
14
            remove_from_index(marked_delete_record)
15
            remove_from_clustered_index(marked_delete_record)
16

17
        # 4. 回收 Undo Log 表空间
18
        truncate_undo_tablespace_if_needed()
19

20
        sleep(purge_interval)  # 默认每 10ms 循环一次

1
// PostgreSQL 行头（HeapTupleHeaderData）
2
struct HeapTupleHeaderData {
3
    TransactionId  xmin;    // 插入该行的事务 ID
4
    TransactionId  xmax;    // 删除/更新该行的事务 ID（0 表示未删除）
5
    CommandId      cid;     // 命令 ID（同一事务内的命令序号）
6
    ItemPointerData t_ctid; // 指向新版本的行指针（更新时）
7
};
8

9
// 版本链：
10
// 旧版本 (xmax=101, t_ctid→新版本) → 新版本 (xmin=101, xmax=0)

1
# PostgreSQL MVCC 可见性判断
2
def pg_is_visible(tuple, snapshot):
3
    """PostgreSQL 行可见性判断"""
4
    xmin = tuple.xmin
5
    xmax = tuple.xmax
6

7
    # xmin 判断：插入是否可见
8
    if xmin == snapshot.xid:
9
        # 同一事务插入
10
        if tuple.cid >= snapshot.curcid:
11
            return False  # 命令 ID >= 当前命令 ID，不可见
12
    elif xmin in snapshot.active_xids:
13
        return False  # 插入事务仍活跃，不可见
14
    elif xmin > snapshot.xmax:
15
        return False  # 插入事务在快照之后，不可见
16

17
    # 到这里，插入可见
18

19
    # xmax 判断：删除/更新是否可见
20
    if xmax == 0:
21
        return True  # 未被删除/更新
22

23
    if xmax == snapshot.xid:
24
        return False  # 被当前事务删除/更新，不可见
25
    elif xmax in snapshot.active_xids:
26
        return True  # 删除/更新事务仍活跃，行仍可见
27
    elif xmax > snapshot.xmax:
28
        return True  # 删除/更新事务在快照之后，行仍可见
29

30
    return False  # 被已提交事务删除/更新，不可见

1
// Visibility Map 结构
2
// 每个数据页对应 1 bit
3
// bit=1: 该页所有行对所有快照可见（无需 VACUUM 扫描）
4
// bit=0: 该页可能包含死行（需要 VACUUM 检查）
5

6
struct VisibilityMap {
7
    uint8_t  map[];  // 位图，每 bit 对应一个数据页
8
    // 1 byte = 8 个页的状态
9
    // 1 MB VM 可管理 8 × 8192 = 65536 个页 = 512MB 数据
10
};

1
# 写-写冲突处理
2
def update_row(row, new_value, txn):
3
    # InnoDB: 用行锁（X Lock）串行化同一行的并发更新
4
    if not acquire_exclusive_lock(row, txn):
5
        wait_or_deadlock_detect()  # 等待或死锁检测
6
        return
7

8
    # 写入 Undo Log
9
    undo_record = create_undo_record(row, old_value)
10
    undo_log.append(undo_record)
11

12
    # 原地更新行
13
    row.value = new_value
14
    row.DB_TRX_ID = txn.id
15
    row.DB_ROLL_PTR = undo_record
16

17
# PostgreSQL: 用行级锁 + 等待
18
def pg_update_row(tuple, new_value, txn):
19
    # 检查行是否被其他事务锁定
20
    if tuple.xmax != 0 and tuple.xmax in active_txns:
21
        wait_for_txn(tuple.xmax)  # 等待持锁事务结束
22

23
    # 标记旧版本为已删除
24
    tuple.xmax = txn.id
25
    tuple.t_ctid = new_tuple_location
26

27
    # 插入新版本
28
    new_tuple = create_new_tuple(new_value, xmin=txn.id, xmax=0)

1
# Autovacuum 触发条件
2
def should_autovacuum(table_stats, config):
3
    """判断是否需要 autovacuum"""
4
    # 基于死行数
5
    dead_tuples = table_stats.n_dead_tup
6
    threshold = config.autovacuum_vacuum_threshold + \
7
                config.autovacuum_vacuum_scale_factor * table_stats.n_live_tup
8

9
    if dead_tuples > threshold:
10
        return True, "dead_tuples"
11

12
    # 基于插入行数（用于冻结）
13
    insert_tuples = table_stats.n_ins_since_vacuum
14
    insert_threshold = config.autovacuum_vacuum_insert_threshold + \
15
                       config.autovacuum_vacuum_insert_scale_factor * table_stats.n_live_tup
16

17
    if insert_tuples > insert_threshold:
18
        return True, "insert_tuples"
19

20
    return False, None
21

22
# 默认配置
23
# autovacuum_vacuum_threshold = 50
24
# autovacuum_vacuum_scale_factor = 0.2
25
# 即：当死行数 > 50 + 20% × 活行数时触发

1
-- 查看事务 ID 冻结信息
2
SELECT
3
    relname,
4
    age(relfrozenxid) AS xid_age,
5
    age(relminmxid) AS mxid_age
6
FROM pg_class
7
WHERE relkind = 'r'
8
ORDER BY xid_age DESC
9
LIMIT 10;
10

11
-- 当 age > 200,000,000 时，autovacuum 会触发冻结
12
-- 当 age > 2,000,000,000 时，数据库会强制停机

1
-- 查看当前活跃事务
2
SELECT * FROM information_schema.innodb_trx;
3

4
-- 查看 Undo Log 信息
5
SHOW STATUS LIKE 'Innodb_undo%';
6

7
-- 查看长事务
8
SELECT
9
    trx_id,
10
    trx_state,
11
    trx_started,
12
    TIMESTAMPDIFF(SECOND, trx_started, NOW()) AS duration_sec,
13
    trx_query
14
FROM information_schema.innodb_trx
15
ORDER BY trx_started;

1
-- 查看表的膨胀情况
2
SELECT
3
    relname,
4
    n_live_tup,
5
    n_dead_tup,
6
    n_dead_tup::float / NULLIF(n_live_tup, 0) AS dead_ratio,
7
    last_vacuum,
8
    last_autovacuum
9
FROM pg_stat_user_tables
10
ORDER BY n_dead_tup DESC;
11

12
-- 查看长事务
13
SELECT
14
    pid,
15
    now() - xact_start AS xact_duration,
16
    now() - query_start AS query_duration,
17
    query
18
FROM pg_stat_activity
19
WHERE xact_start IS NOT NULL
20
ORDER BY xact_start;