Apache Doris 2.1.10:存储结构、索引与查询优化详解
适用版本:Apache Doris 2.1.10
主题:列式存储、Tablet / Rowset / Segment / Page、Prefix Index、ZoneMap、Ordinal Index、压缩编码、向量化执行及查询性能排查。
说明:文中的行数、Offset、Page 大小和耗时均为教学示例,不代表 Doris 固定配置或实测值。实际支持能力与执行路径以 Doris 2.1.10 对应表模型、索引配置和源码为准。
1. 整体存储架构
理解 Doris 底层最重要的逻辑层级是:
text
Table(表)
└── Partition(分区)
└── Tablet(分片 / 桶)
└── Rowset(版本化数据集合)
└── Segment(包含多列的物理文件)
├── Column A
│ ├── Data Page 0
│ ├── Data Page 1
│ └── ...
├── Column B
│ ├── Data Page 0
│ └── ...
├── 各类索引数据 / Index Page
└── Footer(文件元数据)
| 层级 | 作用 | 需要记住的特点 |
|---|---|---|
| Table | 逻辑表和数据模型 | Duplicate / Unique / Aggregate 等模型影响数据组织和合并语义 |
| Partition | 分区和生命周期管理 | 可以进行分区裁剪 |
| Tablet | 数据分布和副本管理的逻辑分片 | 一个 Tablet 有多个副本时,不同 BE 存储对应副本 |
| Rowset | 写入或 Compaction 产生的数据集合 | 带版本范围,通常含一个或多个 Segment |
| Segment | 不可变的列式物理数据文件 | 同一批行的多列数据位于一个 Segment 内 |
| Column | Segment 中的一列 | 每列独立组织、编码和压缩 |
| Data Page | 一列数据的分块存储单位 | 有自己的行范围、文件位置及可用于过滤的元信息 |
Doris 借鉴 LSM-Tree 的不可变数据文件、增量写入和后台合并思想,但不能简单认为其整个存储结构就是标准键值 LSM-Tree。
2. Partition、Tablet、Rowset 和 Segment
2.1 从建表看数据分布
sql
CREATE TABLE orders (
order_id BIGINT,
customer_id BIGINT,
amount DECIMAL(18, 2),
create_time DATETIME,
remark STRING
)
DUPLICATE KEY(order_id, customer_id)
PARTITION BY RANGE(create_time) (
PARTITION p202610 VALUES LESS THAN ('2026-11-01'),
PARTITION p202611 VALUES LESS THAN ('2026-12-01')
)
DISTRIBUTED BY HASH(order_id) BUCKETS 4
PROPERTIES (
"replication_num" = "3"
);
Partition按create_time分隔数据;匹配日期条件的 SQL 可能只扫描某个分区。- 每个分区有 4 个桶,对应 4 个逻辑 Tablet。
HASH(order_id)决定行落入哪个 Tablet;范围查询通常不能像单个等值条件一样直接定位一个桶。replication_num = 3表示每个 Tablet 维护 3 个副本(实际部署必须有足够 BE 等条件)。
Tablet 不是单个文件。 一个 Tablet 内的可见数据来自多个 Rowset,而每个 Rowset 又可能包含多个 Segment 文件。
2.2 Rowset 与版本
概念性示例:
text
Tablet 10001
├── Rowset A Version [0-1]
│ ├── Segment_0.dat
│ └── Segment_1.dat
├── Rowset B Version [2-2]
│ └── Segment_0.dat
└── Rowset C Version [3-3]
└── Segment_0.dat
Doris 通过版本元数据确定一次查询可以看到哪些 Rowset。写入通常产生新的不可变文件,而不是就地修改旧 Segment。Compaction 会将多个旧 Rowset 的内容合并成新的 Rowset。
2.3 一个 Segment 是否包含所有列?
是。 对于普通表存储,一个 Segment 逻辑上保存其所包含行的全部列,而不是"每列对应一个 Segment 文件"。
text
Segment_0.dat(例如 100000 行)
├── order_id → Page 0 / Page 1 / ...
├── customer_id → Page 0 / Page 1 / ...
├── amount → Page 0 / Page 1 / ...
├── remark → Page 0 / Page 1 / ...
├── 索引数据
└── Footer
存储在同一个文件 ≠ 查询会读取这个文件的所有内容。 各列的 Data Page 有独立文件偏移位置,列裁剪可以只读取必要的页。不同列的 Page 数量和边界不必一致。
3. Segment V2 与列式 Data Page
3.1 Segment 文件的逻辑组成
text
Segment V2 (.dat)
├── Data Pages:各列经编码、压缩后的数据
├── Index Pages / Dictionary Pages:按需出现
├── 列和索引相关的附加信息
├── Segment Footer(列元数据、索引位置等)
└── 文件尾部的 Footer 长度、校验及 Magic 等信息
这是逻辑组成,不应理解为所有 Data Page 和索引都必须分别占据一个连续、固定的物理区域。实际通过 Footer 中的定位信息访问相关字节区间。
3.2 行顺序与列组织
假设 Segment 内有下列行:
| Row Ordinal | order_id | customer_id | amount |
|---|---|---|---|
| 0 | 1001 | 200 | 500 |
| 1 | 1002 | 300 | 100 |
| 2 | 1003 | 200 | 800 |
| 3 | 1004 | 400 | 200 |
逻辑列存布局为:
text
order_id : [1001, 1002, 1003, 1004]
customer_id : [ 200, 300, 200, 400]
amount : [ 500, 100, 800, 200]
不同列通过相同的 Segment 行号保持记录对应关系,不能把每列独立按字段值排序,否则同行字段就会错位。
3.3 每列独立切成 Data Page
text
order_id 列:
Page 0 → Row 0~999
Page 1 → Row 1000~1999
remark 列:
Page 0 → Row 0~299
Page 1 → Row 300~699
Page 2 → Row 700~1099
Page 3 → Row 1100~1999
这只是示意。Page 并非固定按 1000 行分割,实际受到目标大小、编码后体积等实现细节影响。像 remark 这类长文本列,通常每 Page 可容纳的行数更少。
3.4 Page 的 Offset 和 Size 保存在哪里?
Page 在 Segment 文件中有相应的物理位置:
text
PagePointer
offset : 在整个 Segment 文件中的字节偏移
size : Page 占用的字节数
在 Doris Segment V2 的 Protobuf 表示里,PagePointerPB 包含 offset 和 size 字段。Offset 是相对整个 Segment 文件,不是相对当前列。
通常通过 Ordinal Index 把行号映射到 Data Page,再通过 PagePointer 读取文件中的指定范围。对于满足特定条件的单 Page 列,实现可直接用 Footer 中的信息定位,不一定需要独立的索引页。
例如:
| amount Page | 起始 Row Ordinal | 文件 Offset | Size |
|---|---|---|---|
| Page 0 | 0 | 12288 | 2048 |
| Page 1 | 1000 | 14336 | 2048 |
| Page 2 | 2000 | 16384 | 3072 |
当查询已确定要读取 amount 的 Row 1500 时,可以通过行号索引定位 Page 1,再用 Offset 和 Size 读取对应字节区间。读取后仍需解压、解码,并取得 Page 内对应行的数据。
4. Page 是否有序,如何定位和扫描
4.1 "顺序存储"不等于"按字段值排序"
Data Page 内的数据按 Row Ordinal 对应的逻辑行序排列,但字段值不一定有序。
例如:
sql
DUPLICATE KEY(order_id)
text
order_id 列(Key):
Page 0 → [1001, 1002, 1003]
Page 1 → [1004, 1005]
amount 列(Value):
Page 0 → [500, 100, 800]
Page 1 → [200, 600]
order_id作为排序 Key 的第一列,在 Segment 内按该排序规则有序。amount不保证按数值大小排序。- Page 内数据可能经过字典、BitShuffle 等编码;磁盘字节布局也不等于逐个原始值顺序摆放,但解码后保持对应逻辑行序。
4.2 组合排序 Key 的细节
sql
DUPLICATE KEY(create_date, customer_id)
排序规则是组合键 (create_date, customer_id) 的字典序,不是 customer_id 全局单调:
| create_date | customer_id |
|---|---|
| 2026-11-01 | 100 |
| 2026-11-01 | 200 |
| 2026-11-02 | 50 |
| 2026-11-02 | 150 |
create_date 整体有序;customer_id 仅在相同 create_date 的组内有序。
4.3 找到 Page 后是不是必须遍历全部数据?
如果 Page 中的目标列无序,而且没有更精细的可用索引或候选行号,那么通常要检查候选 Page 内的值。
text
amount Page = [500, 100, 800, 200, 600, 300]
WHERE amount = 600
比较结果 = [ F, F, F, F, T, F]
但不一定总要扫描整页:
- Key 有序:Prefix Index 缩小行范围后,可以在有序 Key 区域进一步搜索。
- 倒排索引:可提供候选 Row ID,减少遍历。
- ZoneMap:提前排除不可能命中的整个 Page,但不直接指明匹配值在 Page 内的哪个位置。
- 已有 Row ID:通过 Ordinal Index 定位对应 Page 和行;无须为了找这一行而逐值搜索全页。
- 向量化过滤:无序列即使需要扫描,也可以以批为单位高效比较,而不是逐层解释执行每一条记录。
注意:即使已知 Row ID,Page 通常仍需以其编码/压缩单位读取或解码;"不用逐值搜索"并不意味着"只从磁盘读取 8 字节"。
5. Prefix Index、ZoneMap、Ordinal Index 与倒排索引
5.1 总体对比
| 索引 | 工作对象 | 核心内容 | 解决的问题 |
|---|---|---|---|
| Prefix / Short Key Index | 按 Key 排序的 Segment | 稀疏的 Key 前缀与行位置 | 缩小候选行范围 |
| ZoneMap | Segment / Column Data Page 等层级 | Min、Max、Null 等统计 | 跳过不可能命中的数据区域 |
| Ordinal Index | 单列 Data Page | 行号范围与 PagePointer | 按 Row Ordinal 定位 Page |
| 倒排索引(显式创建) | 配置了索引的字段 | 值或词项 → 候选行集合 | 精确检索 / 文本检索等 |
| BloomFilter(按配置) | 适用字段和数据块 | 概率集合信息 | 排除"不存在"的情况;存在假阳性 |
这些索引解决不同问题,能够组合使用。
5.2 Prefix Index:利用排序 Key 稀疏定位
sql
DUPLICATE KEY(order_id, customer_id)
概念性索引:
text
Key 1000 → Row 0
Key 2000 → Row 1024
Key 3000 → Row 2048
查询:
sql
SELECT * FROM orders WHERE order_id = 2500;
前缀索引先将候选范围缩小,再在排序 Key 数据中进一步定位,而不是保存"每个 Key 对应一条行记录"的密集索引。
Doris 2.1 的前缀索引使用排序 Key 前面的有限字节(常见上限为 36 字节 );遇到字符串 Key 列时还有长度截断与后续列停止纳入等规则。它既不是每列都有的索引,也不是一般意义的全文索引。
对于 DUPLICATE KEY(order_id, customer_id):
sql
WHERE order_id = 10001 -- 更利于使用前缀索引
WHERE customer_id = 20001 -- 缺少首列条件,难以高效定位
5.3 ZoneMap:Page 和 Segment 层面的 Min/Max 排除
假设 age 列:
text
Segment ZoneMap: min=10, max=100
Page 0: [10,30,20,40] min=10, max=40
Page 1: [50,70,60,80] min=50, max=80
Page 2: [90,100,85,95] min=85, max=100
查询 WHERE age = 60 时,只有 Page 1 的范围可能包含 60。Page 0 和 Page 2 可被排除,但 Page 1 并不一定真的有 60。
查询 WHERE age = 150 时,甚至可能在 Segment 范围判断阶段就整体排除该 Segment。
ZoneMap 的有效性取决于值的局部集中程度:
text
Page 0: min=1, max=999
Page 1: min=2, max=998
Page 2: min=1, max=1000
如果 WHERE age = 45,三个 Page 的 Min/Max 都包含 45,ZoneMap 无法排除任何一个。
- 局部有序、同值集中:ZoneMap 往往有效。
- 值随机分布、每页范围很宽:ZoneMap 往往作用不大。
ZoneMap不是 B+Tree,也不是 Page 内的定位索引。
5.4 Ordinal Index:从行号到物理 Page
text
已知 Row Ordinal = 1500
↓
Ordinal Index(amount 列)
↓
Page 1 → offset=14336, size=2048
↓
读取 / 解压 / 解码该 Page,获取所需行
这里必须分开理解:
- 逻辑定位:Row Ordinal → Data Page。
- 物理定位:Data Page → Segment 中的 Offset + Size。
5.5 倒排索引:从值到候选行
对于无序列:
text
Row ID : 0 1 2 3 4 5
amount : 500 100 800 600 200 600
倒排结构概念示意:
600 → [3,5]
如果字段建立了合适的倒排索引并且查询能够利用它,就可以先获得候选行集合,避免在所有候选 Page 中通过全量值比较来发现匹配行。具体能否命中索引、是否还要回表或精确校验,取决于索引与谓词类型。
6. STRING / VARCHAR 字段与索引
在 Doris 2.1.10 中,讨论"TEXT 字段"时应先确认实际 SQL 类型。Doris 常用长文本类型是 STRING;VARCHAR 是有长度定义的字符串类型。
| 问题 | 结论 |
|---|---|
STRING 能否作为普通排序 Key? |
Doris 2.1 的常规 Key 定义中不能像 VARCHAR 那样直接作为排序 Key 使用,因此不参与 Key 前缀索引 |
STRING 能否创建倒排索引? |
可按版本支持的索引 DDL 和配置创建,用于适合的等值或全文类查询 |
STRING 一定有高效 ZoneMap 吗? |
不能这样假设;长文本、类型限制与页面统计的实际效果都需要验证 |
VARCHAR 改成 STRING 一定丢失前缀索引吗? |
不一定:如果原来就是非 Key Value 列,它原本就不属于 Short Key 前缀 |
LIKE '%abc%' 能否依靠普通 Key 前缀索引提速? |
通常不能;应评估匹配类型、倒排索引及对应的 NGram 方案 |
示例:
sql
CREATE TABLE test_text (
id BIGINT,
content STRING,
INDEX idx_content(content) USING INVERTED
)
DUPLICATE KEY(id)
DISTRIBUTED BY HASH(id) BUCKETS 4
PROPERTIES ("replication_num" = "1");
上例倒排索引未显式配置分词器,适合演示不分词的索引结构;如需全文检索,则应根据 Doris 2.1 的实际语法配置分词器和匹配谓词,并通过 EXPLAIN / Profile 验证索引是否生效。
如果字段存储订单号、客户编号等较短且经常等值检索的内容,通常优先考虑合理长度的 VARCHAR,再根据排序 Key / 倒排索引设计选择;大段备注或文档文本则更适合 STRING。
7. 一条 SQL 从分区裁剪到 Page 读取
sql
SELECT order_id, amount
FROM orders
WHERE create_time >= '2026-11-01'
AND create_time < '2026-12-01'
AND order_id BETWEEN 1000 AND 2000
AND amount > 500;
可概念化为:
text
SQL 查询
↓
Partition Pruning:排除不相关时间分区
↓
Tablet Pruning:如果分桶键谓词允许,则排除一些 Tablet
↓
读取可见 Rowset / Segment 信息
↓
Short Key:用 order_id 范围缩小候选行
↓
ZoneMap:用 amount 的 Min/Max 排除部分 Segment / Page
↓
Ordinal Index:将候选行号映射到需要的列 Data Page
↓
PagePointer:按 Offset + Size 读取压缩字节
↓
解压、解码,组装列式 Block
↓
向量化过滤、投影、聚合
↓
返回结果
以上是便于教学的逻辑顺序。真实 Scan 中可能并行或组合使用多种过滤器、预取和缓存,不一定严格逐阶段串行。
另外,WHERE 只引用一列,并不表示立即读取 SELECT * 中所有其他列:某些路径能在过滤后才物化剩余列。
8. 列式读取为什么快
8.1 只读需要的列
假设 1 亿行、50 列,每行共 500 字节,而查询只用到两个各 8 字节的字段:
sql
SELECT customer_id, SUM(amount)
FROM orders
WHERE amount > 1000
GROUP BY customer_id;
忽略压缩、元数据和缓存等开销:
- 扫描完整行:
100,000,000 × 500 B = 50 GB。 - 只读两个字段:
100,000,000 × 16 B = 1.6 GB。 - 理想化读取字节数减少约 96.8%,两者相差 31.25 倍。
这不是说耗时必定快 31.25 倍,因为还有过滤、聚合、解压和系统开销。
8.2 列式数据提高 CPU Cache 利用率
对于连续 BIGINT 数据,一个值 8 字节。如果 CPU Cache Line 为 64 字节,一条 Cache Line 理论上可以覆盖 8 个连续整数。
text
列式内存:
[amount0][amount1][amount2][amount3][amount4]...
与每行 500 字节、每次只需其中 8 字节的宽行扫描相比,连续列式访问通常:
- 带来更高的有用数据比例。
- 更有利于硬件预取。
- 减少无关字段占用缓存与内存带宽。
- 为向量化和 SIMD 处理准备紧凑数据布局。
也要注意:行式数据库的覆盖索引等技术可以避免回表;不能把上面的对比绝对化为"所有行存查询都读完整行"。
9. 编码与压缩为什么快
9.1 编码与压缩是两件事
写入 Data Page 时可以概念性地分成:
text
原始列值
↓
Encoding(字典、RLE、BitShuffle、FOR 等适用编码)
↓
Compression(如 LZ4F、ZSTD)
↓
压缩后的 Data Page → Segment
实际编码取决于类型、编码策略和版本,并非每个 Page 都用到所有算法。
字典编码(Dictionary Encoding):
text
原始: [CHINA, CHINA, USA, JAPAN, CHINA]
字典: 0=CHINA, 1=USA, 2=JAPAN
编码: [0, 0, 1, 2, 0]
当重复字符串很多时,把重复值替换成较小整数 ID 通常很划算。
RLE(Run-Length Encoding):
text
原始: [1,1,1,1,1,1,2,2,2,3,3,3,3]
编码: [(1,6),(2,3),(3,4)]
同值连续出现越多,RLE 往往越有效。这也是排序 Key 让相同或相近值集中时,压缩率可能改善的原因之一。
9.2 为什么解压消耗 CPU,整体仍可能更快?
假设未压缩列数据为 1GB:
- 磁盘读取有效吞吐:500MB/s。
- 压缩比:4:1,磁盘只需读取 250MB。
- 解压吞吐:2GB/s。
未压缩读取:
text
1000MB / 500MB/s = 2.0s
压缩后读取再解压(串行上限示意):
text
读取:250MB / 500MB/s = 0.5s
解压:1000MB / 2000MB/s = 0.5s
合计:约 1.0s
示例中虽然多做了解压,整体仍减少约一半时间。实际系统可能存在异步 I/O、流水线重叠与 Page Cache,因此真实时间可能不同。
前提:I/O 节省大于解压开销。如果原始数据都在内存里,或者压缩比低、解码很重,那么压缩可能没有查询延迟收益,甚至拖慢计算。
9.3 其他收益
- 更少磁盘占用,单位容量保存更多历史数据。
- Page Cache / 文件缓存容纳更多压缩数据。
- 远端存储或网络传输(如果涉及)可减少传输字节。
- 相同的 I/O 带宽可服务更多并发查询。
10. 向量化执行为什么快
10.1 逐行迭代的额外成本
传统逐行 Volcano 模型可概念化为:
text
Aggregate.next()
Filter.next()
Scan.next() → 取一行
Aggregate.next()
Filter.next()
Scan.next() → 再取一行
...
对上亿行数据,逐层调用、动态分派、分支以及逐行表达式处理可能产生很大额外开销。
10.2 Doris 按 Block 批处理
Doris 2.1 的向量化引擎使用列式 Block 传递数据:
text
Block(例如 4096 行)
amount : [500,1200,800,1500,2000,...]
customer_id : [101,102,103,104,105,...]
Filter amount > 1000
mask : [F,T,F,T,T,...]
Aggregate → 对符合条件的数据进行 SUM / GROUP BY
4096 是典型批大小示意,并不是固定 Page 行数,更不是"一 Page = 一 Block"。
对于 1 亿行,若每批 4096 行,约需:
text
ceil(100000000 / 4096) = 24415 个 Block
重要区别:算子间传递次数减少,并不表示 1 亿个值不需要被检查。收益来自批量循环、更少解释开销、连续访问、缓存友好以及可能的 SIMD 优化。
10.3 SIMD:单指令多数据
对于 8 个 INT32:
text
amount : [100,200,300,400,500,600,700,800]
条件 : amount > 400
结果 : [ 0, 0, 0, 0, 1, 1, 1, 1]
在适合的指令与实现中,256 位 AVX2 寄存器可一次容纳 8 个 32 位整数,执行并行比较。实际速度受数据加载、掩码处理、分支、算法与 CPU 架构等因素限制。
需要严格区分:
- Batch / Vectorized Execution:以批为单位组织和执行算子。
- SIMD:一条机器指令并行处理多个元素。
向量化不等于每个算子必然使用 SIMD。 对字符串、复杂表达式、哈希聚合等算子,仍需看实际实现。
10.4 三者协同
text
列裁剪:只读取需要的列
↓
编码压缩:从磁盘读取更少字节
↓
解压解码:生成适合计算的列数据
↓
向量化 Block:减少逐行算子开销、改善缓存行为
↓
Filter / Aggregation:尽可能高吞吐地计算
一句话总结:少读取、少传输、快计算。
11. Compaction 如何影响存储与查询
反复写入可能在同一 Tablet 中形成大量 Rowset:
text
Tablet
├── Rowset A [1-1]
├── Rowset B [2-2]
├── Rowset C [3-3]
└── Rowset D [4-4]
即使每个 Segment 内部遵循排序 Key,不同 Rowset 的 Key 范围仍可能相互重叠。
text
Rowset A: [100,200,300]
Rowset B: [150,250,350]
Rowset C: [120,220,320]
查询一个 Key,可能需要检查多个 Rowset。Compaction 会合并与重排数据,生成新的 Rowset 和 Segment,重建相应索引:
text
Rowset A + B + C + D
↓ Compaction
Rowset [1-4]
在 Doris 2.1 中主要涉及:
- Cumulative Compaction:合并较新的增量 Rowset。
- Base Compaction:进一步整理较早的 Rowset。
收益是降低 Rowset / Segment 数量和多文件读开销;代价是后台 CPU、磁盘读写和存储空间压力。
12. 诊断 SQL 与优化建议
12.1 查询元数据
sql
SHOW TABLETS FROM orders;
sql
SHOW TABLET 10001;
查询系统表(字段是否齐备以当前 Doris 2.1.10 实例为准):
sql
SELECT
TABLET_ID,
ROWSET_ID,
START_VERSION,
END_VERSION,
ROWSET_NUM_ROWS,
NUM_SEGMENTS,
DATA_DISK_SIZE,
INDEX_DISK_SIZE
FROM information_schema.rowsets
WHERE TABLET_ID = 10001;
查看 BE 的 Tablet Compaction 信息:
bash
curl "http://BE_IP:8040/api/compaction/show?tablet_id=10001"
将
10001、BE_IP和端口替换为实际环境信息;不同版本和权限配置可能影响接口是否可访问。
12.2 查看查询计划和 Profile
sql
EXPLAIN
SELECT customer_id, SUM(amount)
FROM orders
WHERE amount > 1000
GROUP BY customer_id;
sql
SET enable_profile = true;
SELECT customer_id, SUM(amount)
FROM orders
WHERE amount > 1000
GROUP BY customer_id;
在 Doris Web UI 中找到对应 Query Profile。重点关注对应 Scan / Filter / Aggregation 节点:
| 方向 | 需要关注的统计(实际名称以 Profile 为准) | 分析问题 |
|---|---|---|
| 扫描行数 | RowsRead、RawRowsRead 等 |
是否读入大量无关数据 |
| I/O | BytesRead、压缩读取相关统计 |
是否受磁盘与缓存影响 |
| 解压解码 | DecompressTime 等(若有) |
解压是否明显占用 CPU |
| 过滤 | 表达式和 Predicate 相关耗时 | 谓词是否有效下推 / 过滤 |
| 聚合 | Aggregate 节点耗时、输入行数 | CPU 或高基数字段是否形成瓶颈 |
| 索引过滤 | ZoneMap、Short Key、倒排索引相关统计(若有) | 索引是否真正减少候选页和行 |
Profile 中计数器名称会随执行引擎、查询形态和版本不同而变化,不宜把某一组名称当作所有场景均存在的字段。
12.3 简易优化决策表
| 查询表现 | 优先检查 |
|---|---|
| 只查两列仍读很多数据 | 列裁剪、谓词下推、表模型和扫描行数 |
WHERE 过滤但大量 Page 被扫描 |
排序 Key、ZoneMap 的数据分布、倒排索引 |
大量 STRING 等值查询 |
是否能配置合适的不分词倒排索引 |
| 长文本全文查找 | 分词型倒排索引及查询操作符 |
| Rowset / Segment 很多 | 导入批次、Compaction 状态 |
| 扫描读取不多但 CPU 很高 | 表达式、解码、聚合基数、字符串处理 |
SELECT * 单行查询较慢 |
点查索引、排序 Key、行列混合存储和读放大 |
13. 常见误区与核心结论
误区 1:Segment 是"一列一个文件"
错误。 通常是一个 Segment 文件容纳其行范围内的多列数据及索引,单列数据再分成多个 Page。
误区 2:列数据是顺序保存的,所以列值有序
错误。 所有列保持相同的逻辑行序,只有满足排序 Key 规则的列或组合才具有相应排序属性。
误区 3:所有 Key 字段都各自全局有序
错误。 组合 Key 按字典序排序,非首列通常只在前序 Key 相等的范围内有序。
误区 4:ZoneMap 找到 Page 后能直接定位到某个值
错误。 ZoneMap 仅记录 Min/Max 等统计,以排除不可能包含目标值的 Page,通常不提供 Page 内具体行号。
误区 5:已定位到 Data Page 就一定逐条解释执行
错误。 如果无序且无其他索引,确实需要检查候选值;但 Doris 可批量解码、向量化过滤,还可能利用候选 Row ID 等机制缩小读取范围。
误区 6:列存查询时会读取整个 Segment 文件
错误。 Segment 文件包括多列,但 Data Page 有独立定位,查询一般只需读取相关列和相关 Page。
误区 7:向量化执行等于"一条指令处理 4096 行"
错误。 4096 是典型的 Block 批大小概念;SIMD 是另一层 CPU 指令级并行技术,两者不能混为一谈。
误区 8:压缩一定让查询更快
错误。 当 I/O 是瓶颈且压缩率较好时,减少读取往往抵消解压成本;如果数据已缓存、解码重且压缩收益低,压缩也可能拖慢查询。
最终串联
text
Table → Partition → Tablet → Rowset → Segment
↓
所有列逻辑上放在一个 Segment 内
↓
每一列独立切分 Data Page
↓
Short Key / ZoneMap / Ordinal / Inverted Index
↓
定位候选行、Page 和文件 Offset
↓
按需读取 → 解压 → 解码
↓
Block 向量化过滤 / 聚合 / 返回
核心结论:
- 存储分布 靠 Partition、Tablet;版本和增量写入 靠 Rowset;物理列存靠 Segment、Column、Page。
- Prefix Index 利用排序 Key 定位,ZoneMap 利用范围统计跳页,Ordinal Index 用行号定位 Page;三者职责不同。
- Page 的行序有序 不等于字段数值有序;无序 Page 没有更细索引时,仍然可能需要扫描全部候选值。
- Doris 分析查询高吞吐的基础是列裁剪减少无效读取、编码压缩降低字节量、向量化改善 CPU 执行效率。
- 真正优化生产查询,需要结合 表模型、Key 顺序、数据分布、Index 配置、Compaction 和 Query Profile 判断瓶颈。
14. Block:一批数据如何包含多列
Block 是 BE 向量化执行引擎中的内存批次,并不是 Segment 中的 Data Page。一个 Block 可以包含多列,各列通常有相同的逻辑行数,并以相同下标对应同一条记录。
text
Block(假设 5 行)
├── Column 0 / customer_id / ColumnVector<Int64>
│ [101, 102, 103, 104, 105]
├── Column 1 / amount / ColumnDecimal
│ [500, 1200, 800, 1500, 2000]
└── Column 2 / order_time / 日期时间列
[T1, T2, T3, T4, T5]
同一行:customer_id[3]、amount[3]、order_time[3]
14.1 Block 的概念结构
cpp
// 讲解用简化结构,并非原样摘录 Doris 2.1.10 完整定义
struct ColumnWithTypeAndName {
ColumnPtr column; // 某一列的内存数据
DataTypePtr type; // 列数据类型
std::string name; // 列名
};
class Block {
ColumnsWithTypeAndName data; // 多个列
// 实际还有索引映射和其他成员
};
Block管理一批数据及列元信息。ColumnVector<T>等具体列类型保存列数据;整数、字符串、Nullable、Const 列的内部表示不完全相同。Data Page属于 磁盘存储层 ,Block属于 内存执行层;二者没有一对一的映射关系。- 扫描时可跨多个 Page 填充一个 Block,也可以把同一 Page 的行分多次填入 Block。
源码入口:block.h、column_vector.h。
14.2 过滤如何保持跨列行对应
查询 WHERE amount > 1000 时,一批数据可以形成过滤掩码:
text
customer_id [101, 102, 103, 104, 105]
amount [500,1200, 800,1500,2000]
mask [ 0, 1, 0, 1, 1]
↓
customer_id [102, 104, 105]
amount [1200,1500,2000]
同一个过滤结果应用到需保留的多列,而不是对每列独立筛行。这保证了列之间的行位置关系。
15. 向量化查询的 BE 源码调用链
以下链路用于建立整体认识;真实执行路径由查询计划、谓词下推、Pipeline 算子拆分等决定,不是所有查询都会依次调用这里的每一个接口。
text
FE:解析、优化、生成执行计划
│
▼
BE Scan / SegmentIterator
├── 使用索引缩小候选行范围
└── ColumnIterator::next_batch()
│
▼
vectorized::Block
│
▼
VExprContext::execute() ← 残余表达式过滤/计算
│
▼
Block::filter_block()
│
▼
Aggregate / Project / Join ...
│
▼
结果 Block / Sink
15.1 SegmentIterator 和 ColumnIterator
重点源码:segment_iterator.cpp。
存储层的 SegmentIterator 根据选中的 Row ID 范围,驱动列迭代器批量读取数据。
cpp
// 调用关系示意:并非可直接编译的完整源码
size_t rows_read = requested_rows;
column_iterator->next_batch(&rows_read, destination_column);
// 多个列的结果组织到同一个 Block
其中 ColumnIterator 负责将一列从 Segment 数据页读取到内存列:使用页定位信息,必要时发生磁盘/缓存读取,再解压和解码。批读取的意义在于:避免在查询算子之间每次只交付一行,同时让同类型的数据在更紧凑的循环中处理。
15.2 VExprContext 和 Filter
重点源码:vexpr_context.cpp、block.cpp。
对于 amount > 1000,表达式树逻辑上包含"读取 amount 列""读取常量 1000""大于比较"。执行时一次作用于 Block,生成一个布尔结果列,然后 Block::filter_block() 根据结果缩小行集。
cpp
// 概念伪代码,展示两步职责
int result_column_id = -1;
expr_ctx->execute(&block, &result_column_id); // 生成结果列
Block::filter_block(&block, result_column_id, keep_columns);
注意谓词下推:简单条件可能已在 Segment 扫描阶段由 ColumnPredicate、ZoneMap、倒排索引等提前过滤,未必一定经过独立的执行层 Filter 算子。
15.3 聚合:批输入不等于没有逐行计算
源码入口:vaggregation_node.cpp、aggregate_function_sum.h。
sql
SELECT customer_id, SUM(amount)
FROM orders
GROUP BY customer_id;
分组聚合一般维护 Hash Table,以 customer_id 查找或创建聚合状态,再把对应的 amount 累加进去。
cpp
// 讲解用伪代码
for (size_t i = 0; i < block.rows(); ++i) {
auto& state = hash_table[customer_id[i]];
state.sum += amount[i];
}
Block 让算子按批次接收数据,并可批量准备 Key、Hash 等;但 GROUP BY 的状态更新仍然存在按行/按键操作。向量化不意味着"一条 SIMD 指令完成一整个 GROUP BY"。
15.4 Pipeline、Block 与 SIMD 各做什么?
| 层次 | 核心职责 | 典型问题 |
|---|---|---|
| Block / 向量化算子 | 将多行按列批量处理 | 4096 行怎样少开销地计算? |
| Pipeline 调度 | 串联并调度 Source、Operator、Sink | 哪个线程何时执行哪一批? |
| MPP / Exchange | 将计算分布到多个 BE | 数据与局部聚合结果如何交换? |
| SIMD | 在 CPU 指令级并行处理多个元素 | 一条指令能否同时比较多个整数? |
SIMD 是可能使用的底层加速手段,不能把 Block 批处理直接等同于 SIMD。部分向量函数可能使用专用 SIMD 实现,也可能是经过编译器优化的标量循环。
16. 以查询为例:从 Segment 读取到 Block 输出
sql
SELECT customer_id, SUM(amount) AS total_amount
FROM orders
WHERE amount > 1000
GROUP BY customer_id;
| 阶段 | 核心动作 | 性能收益 |
|---|---|---|
| 1. Scan 初始化 | 根据版本元数据选择 Rowset、Segment;解析 Footer/索引 | 缩小读取范围 |
| 2. Index 过滤 | ZoneMap 等排除不可能命中的页;适用时使用其他索引 | 降低 I/O |
| 3. 列读取 | 只访问 amount、customer_id 等必要列的 Page |
列裁剪 |
| 4. 解压解码 | 将压缩编码页还原为可计算的内存列 | 压缩降低传输成本 |
| 5. 形成 Block | 按同一批逻辑行组织多列数据 | 保持连续内存与批量接口 |
| 6. 过滤 | 对 amount 列批量比较并同步过滤相关列 |
减少逐行算子开销 |
| 7. 聚合 | 对筛选出的 Key 更新 SUM 聚合状态 | 批输入和高效 Hash 聚合 |
| 8. 输出 | 输出聚合后的结果 Block;分布式时可能有 Exchange/Final Aggregate | 降低网络与结果处理开销 |
必须区分的三个粒度:Segment 是物理文件;Data Page 是某一列的存储页;Block 是运行时包含多列的内存批次。它们分别解决"数据放哪里""怎样按页读取""怎样批量计算"的问题。
17. 源码阅读与验证建议
建议按以下顺序阅读 Doris 2.1.10 的源码,避免一开始陷入复杂的 Pipeline 调度细节:
be/src/vec/core/block.h:Block 如何管理多列。be/src/vec/columns/column_vector.h:整数等列的内存表示。be/src/olap/rowset/segment_v2/segment_iterator.cpp:列数据批量读取。be/src/vec/exprs/vexpr_context.cpp:表达式批量计算。be/src/vec/core/block.cpp:Block 过滤。be/src/vec/exec/vaggregation_node.cpp:分组聚合。
bash
git clone https://github.com/apache/doris.git
cd doris
git tag -l '*2.1.10*'
# 查到正式发行 tag/commit 后再 checkout,避免跟 branch-2.1 HEAD 混淆
rg 'SegmentIterator::next_batch|ColumnIterator' be/src/olap/rowset/segment_v2
rg 'VExprContext::execute|filter_block' be/src/vec
rg 'AggregationNode|AggregateFunctionSum' be/src/vec
版本提醒 :上面的 GitHub 阅读链接指向可浏览的 branch-2.1,它未必与 2.1.10 发布时的 Commit 完全相同;精确分析函数签名和实现时必须检出对应发布版本。
参考资料
注:Doris 各版本文档路径和内部接口可能变化。涉及生产配置与具体指标名称时,建议以对应版本的源码、
EXPLAIN与 Query Profile 实际结果为准。