1
// WAL 协议（Write-Ahead Logging Protocol）
2
// 规则 1：修改数据页之前，必须先将对应的日志记录写入磁盘
3
// 规则 2：事务提交之前，必须将所有日志记录写入磁盘
4

5
void wal_protocol_example(page_t *page, log_record_t *record) {
6
    // 正确顺序：先写日志，再修改页面
7
    log_write_and_flush(record);     // 1. 写入并刷盘 WAL
8
    page_modify(page, record->data); // 2. 修改数据页面
9

10
    // 错误顺序：先修改页面，再写日志
11
    // page_modify(page, record->data); // 如果这里崩溃，数据已修改但无日志
12
    // log_write_and_flush(record);     // 无法恢复！
13
}

1
# Group Commit 原理
2
def group_commit(txn_log_records, sync_interval_us=500):
3
    # 将多个事务的日志合并刷盘
4
    batch = []
5
    deadline = now() + sync_interval_us
6

7
    # 收集批次内的事务
8
    while now() < deadline:
9
        if has_pending_txn():
10
            batch.append(collect_log_records())
11
        else:
12
            break
13

14
    # 一次性刷盘
15
    if batch:
16
        fsync(all_records(batch))  # 一次 fsync 提交多个事务
17
        notify_all_committed(batch)

1
// LSN 的使用
2
struct PageHeader {
3
    lsn_t  page_lsn;  // 页面 LSN：最后修改此页的日志记录的 LSN
4
};
5

6
struct LogRecord {
7
    lsn_t  lsn;           // 本记录的 LSN
8
    lsn_t  prev_lsn;      // 同一事务的前一条记录的 LSN
9
    txn_id_t txn_id;      // 事务 ID
10
    page_id_t page_id;    // 修改的页面
11
    uint8_t  type;        // 记录类型
12
    uint16_t length;      // 数据长度
13
    byte     data[];      // 变长数据
14
};
15

16
// WAL 协议的精确表述：
17
// page_lsn >= 最后一条刷盘的日志记录的 LSN
18
// 即：如果 page_lsn < log_flushed_lsn，则页面不能刷盘

1
# ARIES Analysis 阶段（简化）
2
def analysis_phase(log, checkpoint):
3
    """分析日志，确定恢复范围"""
4
    # 从检查点开始的信息
5
    dirty_pages = set(checkpoint.dirty_pages)    # 脏页集合
6
    active_txns = set(checkpoint.active_txns)    # 活跃事务集合
7

8
    # 从检查点的 LSN 开始扫描日志
9
    for record in log.scan_from(checkpoint.lsn):
10
        if record.type == UPDATE:
11
            # 记录修改的页面为脏页
12
            dirty_pages.add(record.page_id)
13
            # 记录活跃事务
14
            active_txns.add(record.txn_id)
15

16
        elif record.type == COMMIT:
17
            # 事务已提交，从活跃集合移除
18
            active_txns.discard(record.txn_id)
19

20
        elif record.type == ABORT:
21
            # 事务已回滚，从活跃集合移除
22
            active_txns.discard(record.txn_id)
23

24
        elif record.type == CLR:
25
            # Compensation Log Record（Undo 产生的日志）
26
            dirty_pages.add(record.page_id)
27

28
    return dirty_pages, active_txns
29
    # dirty_pages: 需要重做的页面
30
    # active_txns: 需要回滚的事务（崩溃时未完成）

1
# ARIES Redo 阶段（简化）
2
def redo_phase(log, dirty_pages, page_lsn_map):
3
    """重放所有已提交事务的修改"""
4
    # 找到最早的脏页 LSN
5
    min_lsn = min(page_lsn_map[p] for p in dirty_pages)
6

7
    # 从 min_lsn 开始重放日志
8
    for record in log.scan_from(min_lsn):
9
        if record.type in (UPDATE, CLR):
10
            page_id = record.page_id
11

12
            # 优化：如果 page_lsn >= record.lsn，跳过
13
            # （页面已经包含了此修改）
14
            if page_id in page_lsn_map and \
15
               page_lsn_map[page_id] >= record.lsn:
16
                continue
17

18
            # 重放修改
19
            apply_redo(record)
20
            page_lsn_map[page_id] = record.lsn
21

22
    # 所有脏页刷盘
23
    flush_all_dirty_pages()

1
# ARIES Undo 阶段（简化）
2
def undo_phase(log, active_txns):
3
    """回滚所有未提交事务"""
4
    # 按事务的最后一个 LSN 逆序处理
5
    for txn_id in active_txns:
6
        # 找到事务的最后一条日志记录
7
        last_lsn = find_last_lsn(txn_id)
8

9
        # 沿 prev_lsn 链逆序回滚
10
        current_lsn = last_lsn
11
        while current_lsn is not None:
12
            record = log.read(current_lsn)
13

14
            # 写入 CLR（Compensation Log Record）
15
            # CLR 记录 Undo 操作，本身也需要 Redo
16
            clr = create_clr(record, current_lsn)
17
            log.append(clr)
18

19
            # 执行 Undo 操作
20
            apply_undo(record)
21

22
            # 移到前一条记录
23
            current_lsn = record.prev_lsn
24

25
        # 写入事务回滚完成记录
26
        log.append(TxnEndRecord(txn_id, ABORT))

1
// CLR 记录
2
struct CLRRecord {
3
    lsn_t     lsn;           // CLR 的 LSN
4
    lsn_t     prev_lsn;      // 同一事务的前一条记录
5
    txn_id_t  txn_id;        // 事务 ID
6
    lsn_t     undo_next_lsn; // 下一条需要 Undo 的记录
7
    // 注意：CLR 没有 prev_lsn 指向被 Undo 的记录
8
    // 而是用 undo_next_lsn 指向下一个要 Undo 的记录
9
    // 这避免了 Undo 过程中的级联回滚
10
};
11

12
// CLR 的作用：
13
// 1. 记录 Undo 操作，使 Undo 本身可 Redo
14
// 2. 如果 Undo 过程中再次崩溃，可以从 CLR 继续
15
// 3. undo_next_lsn 避免重复 Undo

1
-- 查看 InnoDB 检查点信息
2
SHOW ENGINE INNODB STATUS\G
3

4
-- 关键信息：
5
-- Log sequence number: 当前 WAL LSN
6
-- Log flushed up to:   已刷盘的 WAL LSN
7
-- Last checkpoint at:  最后检查点的 LSN
8
-- Modified age:        检查点之后的日志量
9

10
-- 检查点触发条件：
11
-- 1. 日志量超过 innodb_max_dirty_pages_pct
12
-- 2. 日志文件空间不足（循环使用）
13
-- 3. 正常关闭时
14
-- 4. 手动执行 FLUSH TABLES

1
# InnoDB 检查点策略
2
def innodb_checkpoint_strategy():
3
    """InnoDB 检查点策略"""
4
    # 1. 异步刷脏页（Page Cleaner 线程）
5
    #    每秒检查脏页比例，超过阈值加速刷盘
6

7
    # 2. Sharp Checkpoint（关闭时）
8
    #    所有脏页刷盘后才能关闭
9

10
    # 3. Fuzzy Checkpoint（运行时）
11
    #    记录脏页信息，后台逐步刷盘
12

13
    # 检查点 LSN 推进条件：
14
    # - 脏页已刷盘
15
    # - 对应的日志已不再需要
16
    pass

1
// InnoDB Redo Log 架构
2
// 两个固定大小的文件，循环写入
3
// ib_logfile0, ib_logfile1
4

5
struct RedoLog {
6
    // 日志文件大小
7
    uint64_t  file_size;    // 通常 48MB × 2 = 96MB
8

9
    // LSN 范围
10
    lsn_t     lsn;          // 当前写入位置
11
    lsn_t     flushed_lsn;  // 已刷盘位置
12
    lsn_t     checkpoint_lsn; // 检查点位置
13

14
    // Buffer
15
    byte      *buffer;      // 日志缓冲（通常 16MB）
16
    uint64_t  buffer_size;
17
};
18

19
// Redo Log 记录类型
20
enum RedoRecordType {
21
    MLOG_1BYTE    = 1,   // 修改 1 字节
22
    MLOG_2BYTE    = 2,   // 修改 2 字节
23
    MLOG_4BYTE    = 4,   // 修改 4 字节
24
    MLOG_8BYTE    = 8,   // 修改 8 字节
25
    MLOG_REC_INSERT = 9, // 插入记录
26
    MLOG_REC_DELETE = 10, // 删除记录
27
    MLOG_PAGE_CREATE = 11, // 创建页面
28
    MLOG_CHECKPOINT = 12, // 检查点
29
};

1
-- PostgreSQL WAL 配置
2
-- WAL 级别
3
SHOW wal_level;
4
-- minimal: 最少日志（不支持复制）
5
-- replica: 支持复制（默认）
6
-- logical: 支持逻辑复制
7

8
-- WAL 大小
9
SHOW max_wal_size;       -- 默认 1GB
10
SHOW min_wal_size;       -- 默认 80MB
11

12
-- 检查点配置
13
SHOW checkpoint_timeout;  -- 默认 5min
14
SHOW checkpoint_completion_target;  -- 默认 0.9
15

16
-- WAL 刷盘策略
17
SHOW fsync;              -- 默认 on
18
SHOW wal_sync_method;    -- 默认 fdatasync

1
# 模拟 MySQL 崩溃
2
# 方法 1: kill -9
3
kill -9 $(pidof mysqld)
4

5
# 方法 2: 使用 debug 模拟
6
# 在 MySQL 中执行：
7
SET SESSION debug = '+d,crash_before_flush_dirty';
8
INSERT INTO test_table VALUES (1, 'crash test');
9

10
# 重启 MySQL
11
systemctl start mysql
12

13
# 观察恢复日志
14
grep "Recovery" /var/log/mysql/error.log
15
# InnoDB: Starting crash recovery...
16
# InnoDB: Doing recovery: scanned up to log sequence number xxx
17
# InnoDB: Doing recovery: scanned up to log sequence number yyy
18
# InnoDB: Database was not shutdown normally!
19
# InnoDB: Starting crash recovery.

1
# 模拟 PostgreSQL 崩溃
2
kill -9 $(pidof postgres)
3

4
# 重启 PostgreSQL
5
systemctl start postgresql
6

7
# 观察恢复日志
8
grep "recovery" /var/log/postgresql/postgresql-16-main.log
9
# LOG:  database system was interrupted; last known up at 2026-06-07 10:00:00
10
# LOG:  database system was not properly shut down; automatic recovery in progress
11
# LOG:  redo starts at 0/1000028
12
# LOG:  consistent recovery state reached at 0/2000060
13
# LOG:  database system is ready to accept connections

1
# 崩溃恢复时间估算
2
def estimate_recovery_time(checkpoint_lsn, crash_lsn,
3
                            log_size_per_mb=1_000_000,
4
                            redo_speed_mb_per_sec=100):
5
    """估算崩溃恢复时间"""
6
    # 需要重放的日志量
7
    log_to_replay = crash_lsn - checkpoint_lsn
8
    log_mb = log_to_replay / log_size_per_mb
9

10
    # Redo 时间
11
    redo_time = log_mb / redo_speed_mb_per_sec
12

13
    # Undo 时间（取决于未提交事务的数量和大小）
14
    # 通常远小于 Redo 时间
15
    undo_time = redo_time * 0.1  # 估算
16

17
    total_time = redo_time + undo_time
18

19
    print(f"检查点 LSN: {checkpoint_lsn:,}")
20
    print(f"崩溃 LSN:   {crash_lsn:,}")
21
    print(f"需重放日志: {log_mb:.1f} MB")
22
    print(f"Redo 时间:  {redo_time:.2f} 秒")
23
    print(f"Undo 时间:  {undo_time:.2f} 秒")
24
    print(f"总恢复时间: {total_time:.2f} 秒")
25

26
estimate_recovery_time(1_000_000, 100_000_000)
27
# 检查点 LSN: 1,000,000
28
# 崩溃 LSN:   100,000,000
29
# 需重放日志: 99.0 MB
30
# Redo 时间:  0.99 秒
31
# Undo 时间:  0.10 秒
32
# 总恢复时间: 1.09 秒