1
-- InnoDB 写入一条记录的完整路径
2
INSERT INTO users (id, name, email) VALUES (1001, 'Alice', 'alice@example.com');
3

4
-- 1. 写入 Redo Log（WAL）
5
--    顺序写入，保证持久性
6
-- 2. 更新 Buffer Pool 中的数据页
7
--    如果页不在内存中，先从磁盘读取
8
-- 3. 更新聚簇索引（主键 B+ 树）
9
--    可能触发页面分裂
10
-- 4. 写入 Change Buffer（二级索引）
11
--    二级索引的修改异步合并
12
-- 5. 写入 Undo Log（MVCC）
13
--    用于回滚和快照读

1
-- 观察 InnoDB 写入状态
2
SHOW ENGINE INNODB STATUS\G
3

4
-- 关键指标
5
-- Buffer Pool hit rate: 应该 > 99%
6
-- Log sequence number: Redo Log 的 LSN
7
-- Pages read/created/written: 页面 I/O 统计

1
-- InnoDB 读取一条记录的路径
2
SELECT * FROM users WHERE id = 1001;
3

4
-- 1. 检查 Buffer Pool → 命中则直接返回
5
-- 2. 未命中 → 从 B+ 树根节点开始查找
6
-- 3. 非叶节点 → 二分查找确定子节点
7
-- 4. 叶子节点 → 找到数据行
8
-- 5. 如果有自适应哈希索引 → O(1) 直接定位
9

10
-- 范围查询
11
SELECT * FROM users WHERE id BETWEEN 1000 AND 2000;
12

13
-- 1. B+ 树定位到起始键
14
-- 2. 沿叶子节点的链表顺序扫描
15
-- 3. 利用预读（prefetch）优化顺序 I/O

1
// RocksDB 写入流程（Go 伪代码）
2
func (db *RocksDB) Put(key, value []byte) error {
3
    // 1. 写入 WAL（可选，sync 模式保证持久性）
4
    if db.options.WriteSync {
5
        db.wal.Append(key, value)
6
        db.wal.Sync()  // fsync，最耗时的步骤
7
    }
8

9
    // 2. 写入 MemTable（跳表插入，O(log N)）
10
    db.memTable.Put(key, value)
11

12
    // 3. 如果 MemTable 满了
13
    if db.memTable.ApproximateSize() >= db.options.MemTableSize {
14
        // 3a. 将当前 MemTable 切换为 Immutable
15
        db.immutable = db.memTable
16
        // 3b. 创建新的 MemTable
17
        db.memTable = NewMemTable()
18
        // 3c. 后台 Flush Immutable → L0 SSTable
19
        go db.flushImmutable()
20
    }
21

22
    return nil
23
}

1
# RocksDB 写入性能调优参数
2
# 写入缓冲区大小（单个 MemTable）
3
write_buffer_size=64MB
4

5
# 最大 MemTable 数量（超过后阻塞写入）
6
max_write_buffer_number=3
7

8
# L0 层触发 Compaction 的文件数
9
level0_file_num_compaction_trigger=4
10

11
# L0 层停止写入的文件数
12
level0_slowdown_writes_trigger=20
13
level0_stop_writes_trigger=36
14

15
# Compaction 线程数
16
max_background_compactions=4
17

18
# WAL 同步模式
19
# 0: 不同步（最快，可能丢数据）
20
# 1: 周期同步（折中）
21
# 2: 每次写入同步（最慢，最安全）
22
wal_sync_mode=2

1
// RocksDB 读取流程（Go 伪代码）
2
func (db *RocksDB) Get(key []byte) ([]byte, error) {
3
    // 1. 查 MemTable
4
    if val, ok := db.memTable.Get(key); ok {
5
        return val, nil
6
    }
7

8
    // 2. 查 Immutable MemTable
9
    if db.immutable != nil {
10
        if val, ok := db.immutable.Get(key); ok {
11
            return val, nil
12
        }
13
    }
14

15
    // 3. 查 Block Cache
16
    if val, ok := db.blockCache.Get(key); ok {
17
        return val, nil
18
    }
19

20
    // 4. 查 L0 SSTable（可能有范围重叠，需要查多个）
21
    for _, sst := range db.levels[0].files {
22
        if sst.MayContain(key, db.bloomFilter) {
23
            if val, ok := sst.Get(key); ok {
24
                db.blockCache.Put(key, val)
25
                return val, nil
26
            }
27
        }
28
    }
29

30
    // 5. 查 L1 → L2 → ... → LN（每层最多查一个文件）
31
    for level := 1; level <= db.maxLevel; level++ {
32
        sst := db.levels[level].FindFile(key)
33
        if sst != nil && sst.MayContain(key, db.bloomFilter) {
34
            if val, ok := sst.Get(key); ok {
35
                db.blockCache.Put(key, val)
36
                return val, nil
37
            }
38
        }
39
    }
40

41
    return nil, ErrNotFound
42
}

1
// TiKV 使用两个 RocksDB 实例
2
// 1. raft_db: 存储 Raft Log
3
//    - 配置为写入优先
4
//    - 较小的 write_buffer_size
5
//    - 独立的 Compaction 线程
6

7
// 2. kv_db: 存储用户数据
8
//    - 标准 LSM 配置
9
//    - Block Cache 共享
10
//    - Column Family 分离 Raft 状态和用户数据
11

12
// TiKV 数据编码格式
13
// Key:   {table_id}_{index_id}_{encoded_key}_{timestamp}
14
// Value: {type_flag}{encoded_value}
15
//
16
// MVCC 通过 timestamp 后缀实现：
17
// Put(key, value, ts=100)  →  key_100 → value
18
// Put(key, value, ts=200)  →  key_200 → value
19
// Get(key, ts=150)         →  找到 ts <= 150 的最大版本 → key_100 → value

1
// TiKV 写入流程（简化）
2
// 1. 客户端 → PD 获取 Region Leader 位置
3
// 2. 客户端 → Region Leader 发起 Propose
4
// 3. Leader 将写请求追加到 Raft Log
5
// 4. Raft Log 复制到 Follower
6
// 5. 多数派确认后，Leader Apply 写入
7
// 6. Apply: 写入 RaftDB + 写入 KV DB
8

9
// 写入延迟分解
10
// Raft Propose:     ~0.1ms  (内存操作)
11
// Raft Replicate:   ~1-3ms  (网络 RTT，跨机房更高)
12
// Raft Apply:       ~0.5ms  (RocksDB 写入)
13
// 总延迟:           ~2-5ms  (单次写入)

1
-- TiDB 中观察 TiKV 写入性能
2
-- 查看Region分布
3
SELECT
4
    store_id,
5
    COUNT(*) AS region_count,
6
    SUM(approximate_size) AS total_size_mb
7
FROM information_schema.tikv_region_status
8
GROUP BY store_id;
9

10
-- 查看写入延迟
11
SELECT
12
    instance,
13
    SUM(rate) AS write_rate
14
FROM information_schema.tikv_store_status
15
GROUP BY instance;

1
// TiKV 读取流程
2
// 1. Leader Read（默认）
3
//    - 请求发送到 Region Leader
4
//    - Leader 从本地 RocksDB 读取
5
//    - 需要检查 Lease 确保自己是 Leader
6

7
// 2. Follower Read（v3.0+）
8
//    - 请求可发送到任意副本
9
//    - 副本需要向 Leader 申请 Read Index
10
//    - 等待 State Machine >= Read Index 后读取
11
//    - 减轻 Leader 压力
12

13
// 3. Coprocessor 下推
14
//    - 将过滤/聚合下推到 TiKV 执行
15
//    - 减少网络传输量
16
//    - 利用 SSE/AVX 向量化执行

1
InnoDB 写放大分解：
2
  1. Redo Log 写入：1x（顺序写）
3
  2. 数据页写回：1x（随机写，但 Buffer Pool 缓解）
4
  3. Doublewrite：1x（额外写一次防撕裂）
5
  4. Undo Log：0.5x（回滚段）
6
  总计：~3-4x
7

8
RocksDB 写放大分解：
9
  1. WAL 写入：1x
10
  2. MemTable → L0 Flush：1x
11
  3. L0 → L1 Compaction：1x
12
  4. L1 → L2 Compaction：~10x（L2 是 L1 的 10 倍大小）
13
  5. L2 → L3 Compaction：~10x
14
  总计：~20-30x（取决于层级数和大小比例）
15

16
TiKV 写放大分解：
17
  1. Raft Log 写入（RaftDB）：1x
18
  2. Raft Apply 写入（KVDB）：同 RocksDB 放大
19
  3. 3 副本：3x
20
  总计：Raft(1x) + 3 × RocksDB(~20x) = ~60x
21
  实际优化后：~30-40x（Raft Log 复用、Pipeline 优化）

1
-- MyRocks: 使用 RocksDB 替代 InnoDB 作为 MySQL 存储引擎
2
-- 优势：压缩率更高（约 50% 空间节省），写入吞吐更高
3
-- 劣势：读取性能略低，范围扫描不如 InnoDB
4

5
-- 创建 MyRocks 表
6
CREATE TABLE users (
7
    id BIGINT PRIMARY KEY,
8
    name VARCHAR(255),
9
    email VARCHAR(255),
10
    INDEX idx_email (email)
11
) ENGINE=ROCKSDB;
12

13
-- MyRocks 压缩配置
14
SET SESSION rocksdb_default_cf_options=
15
  'compression=kLZ4Compression;bottommost_compression=kZSTD';

1
-- TiDB HTAP: TiKV（行存）+ TiFlash（列存）
2
-- TiKV: 服务 OLTP 负载
3
-- TiFlash: 服务 OLAP 负载
4
-- 通过 Raft Learner 异步复制数据
5

6
-- 创建表并启用 TiFlash 副本
7
CREATE TABLE orders (
8
    id BIGINT PRIMARY KEY,
9
    user_id BIGINT,
10
    amount DECIMAL(10,2),
11
    created_at DATETIME,
12
    INDEX idx_user (user_id)
13
);
14

15
-- 添加 TiFlash 副本
16
ALTER TABLE orders SET TIFLASH REPLICA 2;
17

18
-- OLTP 查询走 TiKV
19
SELECT * FROM orders WHERE id = 1001;
20

21
-- OLAP 查询走 TiFlash
22
SELECT user_id, SUM(amount)
23
FROM orders
24
WHERE created_at >= '2026-01-01'
25
GROUP BY user_id;