TiDB Server #
一、TiDB Server概述 #
1.1 核心定位 #
TiDB Server 是 TiDB 集群的计算层，负责处理 SQL 请求。
text
TiDB Server 核心职责
├── 协议层
│ ├── MySQL 协议兼容
│ ├── 连接管理
│ └── 权限验证
│
├── SQL处理
│ ├── SQL 解析
│ ├── 查询优化
│ └── 执行计划生成
│
├── 执行层
│ ├── 本地执行
│ ├── 分布式执行
│ └── 结果聚合
│
└── 事务管理
├── 事务开始
├── 事务提交
└── 事务回滚
1.2 无状态设计 #
text
┌─────────────────────────────────────────────────────────────┐
│ TiDB Server 特点 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 无状态: │
│ ├── 不存储用户数据 │
│ ├── 可随意启停 │
│ ├── 水平扩展 │
│ └── 负载均衡 │
│ │
│ 存储的信息: │
│ ├── 会话信息 (内存) │
│ ├── 缓存信息 (可配置) │
│ └── 统计信息 (定期持久化) │
│ │
└─────────────────────────────────────────────────────────────┘
二、SQL处理流程 #
2.1 完整处理流程 #
text
SQL 请求处理流程
┌─────────────────────────────────────────────────────────────┐
│ │
│ Client │
│ │ │
│ │ MySQL Protocol │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 1. 连接管理 │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ - 连接建立 │ │ │
│ │ │ - 权限验证 │ │ │
│ │ │ - 会话管理 │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 2. SQL 解析 │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ SQL String │ │ │
│ │ │ ↓ │ │ │
│ │ │ 词法分析 (Lexer) │ │ │
│ │ │ ↓ │ │ │
│ │ │ 语法分析 (Parser) │ │ │
│ │ │ ↓ │ │ │
│ │ │ AST (抽象语法树) │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 3. 预处理 │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ - 名称解析 │ │ │
│ │ │ - 类型检查 │ │ │
│ │ │ - 权限检查 │ │ │
│ │ │ - 语义验证 │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 4. 查询优化 │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ 逻辑优化 │ │ │
│ │ │ ↓ │ │ │
│ │ │ 物理优化 │ │ │
│ │ │ ↓ │ │ │
│ │ │ 执行计划 │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 5. 执行器 │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ - 构建执行器 │ │ │
│ │ │ - 执行算子 │ │ │
│ │ │ - 返回结果 │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ Client │
│ 返回结果 │
│ │
└─────────────────────────────────────────────────────────────┘
2.2 连接管理 #
sql
-- 查看当前连接
SHOW PROCESSLIST;
-- 详细连接信息
SHOW FULL PROCESSLIST;
-- 系统表查询
SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST;
-- 连接参数
SHOW VARIABLES LIKE 'max_connections';
SHOW VARIABLES LIKE 'wait_timeout';
连接池配置
text
应用连接池配置建议
┌─────────────────────────────────────────────────────────────┐
│ │
│ 参数 推荐值 说明 │
│ ──────────────────────────────────────────────────────── │
│ maxPoolSize CPU核心数 * 2 + 1 最大连接数 │
│ minPoolSize CPU核心数 最小连接数 │
│ connectionTimeout 30000 (ms) 连接超时 │
│ idleTimeout 600000 (ms) 空闲超时 │
│ maxLifetime 1800000 (ms) 最大生命周期 │
│ │
└─────────────────────────────────────────────────────────────┘
2.3 SQL解析 #
词法分析
text
词法分析示例
┌─────────────────────────────────────────────────────────────┐
│ │
│ 输入: SELECT name FROM users WHERE id = 1 │
│ │
│ 词法分析结果: │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Token │ Type │ Value │ │
│ ├───────────────┼────────────┼────────────────────────┤ │
│ │ SELECT │ keyword │ "SELECT" │ │
│ │ name │ identifier │ "name" │ │
│ │ FROM │ keyword │ "FROM" │ │
│ │ users │ identifier │ "users" │ │
│ │ WHERE │ keyword │ "WHERE" │ │
│ │ id │ identifier │ "id" │ │
│ │ = │ operator │ "=" │ │
│ │ 1 │ number │ 1 │ │
│ └───────────────┴────────────┴────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
语法分析
text
AST 结构示例
┌─────────────────────────────────────────────────────────────┐
│ │
│ SQL: SELECT name FROM users WHERE id = 1 │
│ │
│ AST: │
│ SelectStmt │
│ / | \ │
│ SelectList From Where │
│ │ │ │ │
│ name users BinaryOperation │
│ / \ │
│ id = 1 │
│ │
└─────────────────────────────────────────────────────────────┘
三、查询优化器 #
3.1 优化器架构 #
text
查询优化器架构
┌─────────────────────────────────────────────────────────────┐
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 逻辑优化 │ │
│ │ │ │
│ │ 输入: 逻辑计划 │ │
│ │ │ │
│ │ 优化规则: │ │
│ │ ├── 常量折叠 │ │
│ │ ├── 谓词下推 │ │
│ │ ├── 投影下推 │ │
│ │ ├── Join 消除 │ │
│ │ ├── 子查询展开 │ │
│ │ └── ... │ │
│ │ │ │
│ │ 输出: 优化后的逻辑计划 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 物理优化 │ │
│ │ │ │
│ │ 输入: 逻辑计划 │ │
│ │ │ │
│ │ 优化选择: │ │
│ │ ├── 扫描方式选择 │ │
│ │ │ ├── 全表扫描 │ │
│ │ │ └── 索引扫描 │ │
│ │ │ │ │
│ │ ├── Join 方式选择 │ │
│ │ │ ├── Hash Join │ │
│ │ │ ├── Merge Join │ │
│ │ │ └── Index Join │ │
│ │ │ │ │
│ │ ├── 聚合方式选择 │ │
│ │ │ ├── Hash Aggregation │ │
│ │ │ └── Stream Aggregation │ │
│ │ │ │ │
│ │ └── 代价估算 │ │
│ │ ├── CPU 代价 │ │
│ │ ├── IO 代价 │ │
│ │ └── 内存代价 │ │
│ │ │ │
│ │ 输出: 物理执行计划 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
3.2 逻辑优化规则 #
谓词下推
sql
-- 原始查询
SELECT u.name, o.order_no
FROM users u
JOIN orders o ON u.id = o.user_id
WHERE u.status = 'active' AND o.amount > 100;
-- 优化后执行顺序
-- 1. 先过滤 users.status = 'active'
-- 2. 先过滤 orders.amount > 100
-- 3. 再执行 Join
text
谓词下推过程
┌─────────────────────────────────────────────────────────────┐
│ │
│ 优化前: │
│ │
│ ┌─────────────┐ │
│ │ Selection │ WHERE u.status='active' │
│ │ │ AND o.amount>100 │
│ └──────┬──────┘ │
│ │ │
│ ┌──────┴──────┐ │
│ │ Join │ │
│ └──────┬──────┘ │
│ ┌─────┴─────┐ │
│ │ │ │
│ ┌────┴────┐ ┌────┴────┐ │
│ │ users │ │ orders │ │
│ └─────────┘ └─────────┘ │
│ │
│ ───────────────────────────────────────────────────── │
│ │
│ 优化后: │
│ │
│ ┌─────────────┐ │
│ │ Join │ │
│ └──────┬──────┘ │
│ ┌─────┴─────┐ │
│ │ │ │
│ ┌────┴────┐ ┌────┴────┐ │
│ │Selection│ │Selection│ │
│ │status= │ │amount> │ │
│ │'active' │ │ 100 │ │
│ └────┬────┘ └────┬────┘ │
│ │ │ │
│ ┌────┴────┐ ┌────┴────┐ │
│ │ users │ │ orders │ │
│ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
投影下推
sql
-- 原始查询
SELECT u.name
FROM users u
WHERE u.status = 'active';
-- 优化后只读取 name 和 status 列
-- 不读取其他列如 email, phone 等
子查询展开
sql
-- 原始子查询
SELECT * FROM orders
WHERE user_id IN (SELECT id FROM users WHERE status = 'active');
-- 展开为 Join
SELECT o.*
FROM orders o
JOIN users u ON o.user_id = u.id
WHERE u.status = 'active';
3.3 物理优化选择 #
扫描方式选择
sql
-- 全表扫描 vs 索引扫描
-- 场景1: 高选择性，使用索引
SELECT * FROM users WHERE id = 1;
-- 场景2: 低选择性，可能全表扫描
SELECT * FROM users WHERE status = 'active'; -- 假设80%是active
-- 查看执行计划
EXPLAIN SELECT * FROM users WHERE id = 1;
EXPLAIN SELECT * FROM users WHERE status = 'active';
Join方式选择
text
Join 方式对比
┌─────────────────────────────────────────────────────────────┐
│ │
│ Hash Join: │
│ ├── 构建小表的 Hash 表 │
│ ├── 探测大表 │
│ ├── 适合: 大表 Join 大表 │
│ └── 内存消耗较大 │
│ │
│ Merge Join: │
│ ├── 两表按 Join Key 排序 │
│ ├── 顺序扫描匹配 │
│ ├── 适合: 已排序数据 │
│ └── 内存消耗小 │
│ │
│ Index Join: │
│ ├── 遍历外表 │
│ ├── 通过索引查找内表 │
│ ├── 适合: 外表小、内表有索引 │
│ └── 随机 IO 较多 │
│ │
└─────────────────────────────────────────────────────────────┘
sql
-- 强制使用特定 Join 方式
SELECT /*+ HASH_JOIN(u, o) */ u.name, o.order_no
FROM users u
JOIN orders o ON u.id = o.user_id;
SELECT /*+ MERGE_JOIN(u, o) */ u.name, o.order_no
FROM users u
JOIN orders o ON u.id = o.user_id;
SELECT /*+ INL_JOIN(o) */ u.name, o.order_no
FROM users u
JOIN orders o ON u.id = o.user_id;
3.4 统计信息 #
sql
-- 查看表统计信息
SHOW STATS_META WHERE table_name = 'users';
-- 查看列统计信息
SHOW STATS_HISTOGRAMS WHERE table_name = 'users';
-- 查看直方图
SHOW STATS_BUCKETS WHERE table_name = 'users' AND column_name = 'status';
-- 手动收集统计信息
ANALYZE TABLE users;
-- 收集指定列
ANALYZE TABLE users COLUMNS id, status;
-- 设置采样率
SET SESSION tidb_analyze_version = 2;
ANALYZE TABLE users WITH 10000 SAMPLERATE;
四、执行引擎 #
4.1 执行器架构 #
text
执行器架构
┌─────────────────────────────────────────────────────────────┐
│ │
│ 执行计划 │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 执行器构建 │ │
│ │ │ │
│ │ Plan → Executor │ │
│ │ │ │
│ │ ┌───────────────┐ │ │
│ │ │ Projection │ │ │
│ │ │ Executor │ │ │
│ │ └───────┬───────┘ │ │
│ │ │ │ │
│ │ ┌───────┴───────┐ │ │
│ │ │ Selection │ │ │
│ │ │ Executor │ │ │
│ │ └───────┬───────┘ │ │
│ │ │ │ │
│ │ ┌───────┴───────┐ │ │
│ │ │ TableReader │ │ │
│ │ │ Executor │ │ │
│ │ └───────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 数据流转 │ │
│ │ │ │
│ │ 火山模型: Next() 调用链 │ │
│ │ │ │
│ │ 向量化执行: 批量处理 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
4.2 火山模型 #
text
火山模型执行过程
┌─────────────────────────────────────────────────────────────┐
│ │
│ 查询: SELECT name FROM users WHERE id = 1 │
│ │
│ 执行器树: │
│ │
│ ┌───────────────┐ │
│ │ Projection │ ← Next() 返回 name │
│ │ Executor │ │
│ └───────┬───────┘ │
│ │ 调用 Next() │
│ ┌───────┴───────┐ │
│ │ Selection │ ← 过滤 id = 1 │
│ │ Executor │ │
│ └───────┬───────┘ │
│ │ 调用 Next() │
│ ┌───────┴───────┐ │
│ │ TableReader │ ← 从 TiKV 读取数据 │
│ │ Executor │ │
│ └───────────────┘ │
│ │
│ 执行流程: │
│ 1. Projection 调用 Selection.Next() │
│ 2. Selection 调用 TableReader.Next() │
│ 3. TableReader 返回一行数据 │
│ 4. Selection 检查条件，返回符合的行 │
│ 5. Projection 提取 name 列 │
│ 6. 重复直到没有数据 │
│ │
└─────────────────────────────────────────────────────────────┘
4.3 向量化执行 #
text
向量化执行
┌─────────────────────────────────────────────────────────────┐
│ │
│ 传统执行 (逐行): │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ for row in table: │ │
│ │ if condition(row): │ │
│ │ result.append(project(row)) │ │
│ │ │ │
│ │ 问题: 函数调用开销大，CPU缓存效率低 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 向量化执行 (批量): │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ batch = fetch_batch(1024) # 一次取1024行 │ │
│ │ mask = condition_batch(batch) # 批量过滤 │ │
│ │ result = project_batch(batch[mask]) # 批量投影 │ │
│ │ │ │
│ │ 优势: 减少函数调用，提高CPU缓存命中率 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
五、分布式执行 #
5.1 分布式执行框架 #
text
分布式执行架构
┌─────────────────────────────────────────────────────────────┐
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ TiDB Server │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ 查询优化器 │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ 执行计划 │ │ │
│ │ │ │ │ │
│ │ │ Root Task (协调者) │ │ │
│ │ │ │ │ │ │
│ │ │ ┌────┴────────────────────┐ │ │ │
│ │ │ │ │ │ │ │
│ │ │ ▼ ▼ │ │ │
│ │ │ Cop Task 1 Cop Task 2 │ │ │
│ │ │ (TiKV 1) (TiKV 2) │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────┼───────────────┐ │
│ ▼ ▼ ▼ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ TiKV 1 │ │ TiKV 2 │ │ TiKV 3 │ │
│ │ │ │ │ │ │ │
│ │ Coprocessor │ │ Coprocessor │ │ Coprocessor │ │
│ │ - 过滤 │ │ - 过滤 │ │ - 过滤 │ │
│ │ - 聚合 │ │ - 聚合 │ │ - 聚合 │ │
│ │ - 排序 │ │ - 排序 │ │ - 排序 │ │
│ └───────────────┘ └───────────────┘ └───────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
5.2 Coprocessor下推 #
sql
-- 查询示例
SELECT COUNT(*), AVG(amount)
FROM orders
WHERE status = 'completed' AND created_at > '2024-01-01';
-- 执行计划
EXPLAIN SELECT COUNT(*), AVG(amount)
FROM orders
WHERE status = 'completed' AND created_at > '2024-01-01';
text
Coprocessor 下推过程
┌─────────────────────────────────────────────────────────────┐
│ │
│ 不下推 (传统方式): │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ TiKV 1 → 返回 100万行 → TiDB │ │
│ │ TiKV 2 → 返回 100万行 → TiDB │ │
│ │ TiKV 3 → 返回 100万行 → TiDB │ │
│ │ │ │
│ │ TiDB: 过滤 + 聚合 (处理300万行) │ │
│ │ │ │
│ │ 问题: 网络传输大量数据 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 下推 (优化方式): │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ TiKV 1: 过滤 + 聚合 → 返回 1 行结果 │ │
│ │ TiKV 2: 过滤 + 聚合 → 返回 1 行结果 │ │
│ │ TiKV 3: 过滤 + 聚合 → 返回 1 行结果 │ │
│ │ │ │
│ │ TiDB: 汇总 3 行结果 │ │
│ │ │ │
│ │ 优势: 大幅减少网络传输 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
5.3 MPP执行 #
text
MPP (Massively Parallel Processing) 执行
┌─────────────────────────────────────────────────────────────┐
│ │
│ 查询: │
│ SELECT region, SUM(amount) │
│ FROM orders │
│ GROUP BY region; │
│ │
│ MPP 执行计划: │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ TiDB Server │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ 查询协调器 │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────┼───────────────┐ │
│ ▼ ▼ ▼ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ TiFlash 1 │ │ TiFlash 2 │ │ TiFlash 3 │ │
│ │ │ │ │ │ │ │
│ │ 本地聚合 │ │ 本地聚合 │ │ 本地聚合 │ │
│ │ region A │ │ region B │ │ region C │ │
│ │ SUM = 1000 │ │ SUM = 2000 │ │ SUM = 3000 │ │
│ └───────────────┘ └───────────────┘ └───────────────┘ │
│ │
│ 特点: │
│ - 每个 TiFlash 独立执行部分计算 │
│ - 没有单点瓶颈 │
│ - 线性扩展能力 │
│ │
└─────────────────────────────────────────────────────────────┘
sql
-- 启用 MPP
SET SESSION tidb_allow_mpp = 1;
-- 强制使用 MPP
SET SESSION tidb_enforce_mpp = 1;
-- 查看 MPP 执行计划
EXPLAIN SELECT region, SUM(amount)
FROM orders
GROUP BY region;
六、执行计划分析 #
6.1 查看执行计划 #
sql
-- 基本执行计划
EXPLAIN SELECT * FROM users WHERE id = 1;
-- 详细执行计划
EXPLAIN ANALYZE SELECT * FROM users WHERE id = 1;
-- 格式化输出
EXPLAIN FORMAT = 'row' SELECT * FROM users WHERE id = 1;
EXPLAIN FORMAT = 'brief' SELECT * FROM users WHERE id = 1;
EXPLAIN FORMAT = 'dot' SELECT * FROM users WHERE id = 1;
6.2 执行计划解读 #
text
执行计划示例
┌─────────────────────────────────────────────────────────────┐
│ │
│ id │ task │ operator info │
│ ─────────────────────┼──────┼────────────────────────── │
│ Projection_4 │ root │ name │
│ └─Selection_5 │ root │ eq(id, 1) │
│ └─TableReader_7 │ root │ data: Selection_6 │
│ └─Selection_6 │ cop │ eq(id, 1) │
│ └─TableScan_8 │ cop │ table:users, range:[1,1] │
│ │
│ 解读: │
│ 1. TableScan_8: 扫描 users 表，范围 [1, 1] │
│ 2. Selection_6: 在 TiKV 上过滤 id = 1 │
│ 3. TableReader_7: 从 TiKV 读取数据 │
│ 4. Selection_5: 在 TiDB 上再次过滤 │
│ 5. Projection_4: 投影 name 列 │
│ │
│ task 说明: │
│ - root: 在 TiDB Server 执行 │
│ - cop: 在 TiKV Coprocessor 执行 │
│ │
└─────────────────────────────────────────────────────────────┘
6.3 常见算子 #
| 算子 | 说明 |
|---|---|
| TableScan | 全表扫描 |
| IndexScan | 索引扫描 |
| IndexReader | 索引读取 |
| TableReader | 表数据读取 |
| Selection | 过滤 |
| Projection | 投影 |
| HashJoin | Hash 连接 |
| MergeJoin | Merge 连接 |
| IndexJoin | 索引连接 |
| HashAgg | Hash 聚合 |
| StreamAgg | 流式聚合 |
| Sort | 排序 |
| TopN | Top N |
| Limit | 限制行数 |
6.4 优化Hints #
sql
-- 使用索引
SELECT /*+ USE_INDEX(users idx_status) */
* FROM users WHERE status = 'active';
-- 强制索引
SELECT /*+ FORCE_INDEX(users idx_status) */
* FROM users WHERE status = 'active';
-- 不使用索引
SELECT /*+ IGNORE_INDEX(users idx_status) */
* FROM users WHERE status = 'active';
-- Join 顺序
SELECT /*+ LEADING(orders, users) */
u.name, o.order_no
FROM users u
JOIN orders o ON u.id = o.user_id;
-- Join 方式
SELECT /*+ HASH_JOIN(u, o) */
u.name, o.order_no
FROM users u
JOIN orders o ON u.id = o.user_id;
-- 并行度
SELECT /*+ MAX_EXECUTION_TIME(10000) */
* FROM large_table;
-- 内存限制
SELECT /*+ MEMORY_QUOTA(1 GB) */
* FROM large_table GROUP BY col1;
七、配置调优 #
7.1 内存配置 #
sql
-- 查看内存配置
SHOW VARIABLES LIKE '%memory%';
-- 设置内存限制
SET GLOBAL tidb_server_memory_limit = "80%";
-- 查询内存使用
SET GLOBAL tidb_server_memory_limit_gc_trigger = 0.7;
7.2 并行配置 #
sql
-- 并发执行
SET SESSION tidb_distsql_scan_concurrency = 15;
SET SESSION tidb_index_lookup_concurrency = 15;
SET SESSION tidb_hash_join_concurrency = 5;
-- MPP 配置
SET SESSION tidb_max_tiflash_threads = 4;
7.3 缓存配置 #
sql
-- Prepared Plan Cache
SET SESSION tidb_enable_prepared_plan_cache = ON;
SET SESSION tidb_prepared_plan_cache_size = 100;
-- 统计信息缓存
SET GLOBAL tidb_stats_cache_mem_quota = 2000000000;
八、总结 #
TiDB Server 核心要点：
| 模块 | 要点 |
|---|---|
| SQL解析 | 词法分析 → 语法分析 → AST |
| 查询优化 | 逻辑优化 → 物理优化 → 执行计划 |
| 执行引擎 | 火山模型 → 向量化执行 |
| 分布式执行 | Coprocessor下推 → MPP并行 |
| 调优 | 统计信息 → Hints → 配置 |
下一步，让我们深入学习 TiKV 存储引擎！
最后更新：2026-03-27