Apache Doris 2.1.10:存储结构、索引与查询优化详解

0 阅读28分钟

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 底层最重要的逻辑层级是:

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 内
ColumnSegment 中的一列每列独立组织、编码和压缩
Data Page一列数据的分块存储单位有自己的行范围、文件位置及可用于过滤的元信息

Doris 借鉴 LSM-Tree 的不可变数据文件、增量写入和后台合并思想,但不能简单认为其整个存储结构就是标准键值 LSM-Tree。

2. Partition、Tablet、Rowset 和 Segment

2.1 从建表看数据分布

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 与版本

概念性示例:

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 文件”。

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 文件的逻辑组成

Segment V2 (.dat)
  ├── Data Pages:各列经编码、压缩后的数据
  ├── Index Pages / Dictionary Pages:按需出现
  ├── 列和索引相关的附加信息
  ├── Segment Footer(列元数据、索引位置等)
  └── 文件尾部的 Footer 长度、校验及 Magic 等信息

这是逻辑组成,不应理解为所有 Data Page 和索引都必须分别占据一个连续、固定的物理区域。实际通过 Footer 中的定位信息访问相关字节区间。

3.2 行顺序与列组织

假设 Segment 内有下列行:

Row Ordinalorder_idcustomer_idamount
01001200500
11002300100
21003200800
31004400200

逻辑列存布局为:

order_id    : [1001, 1002, 1003, 1004]
customer_id : [ 200,  300,  200,  400]
amount      : [ 500,  100,  800,  200]

不同列通过相同的 Segment 行号保持记录对应关系,不能把每列独立按字段值排序,否则同行字段就会错位。

3.3 每列独立切成 Data Page

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 文件中有相应的物理位置:

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文件 OffsetSize
Page 00122882048
Page 11000143362048
Page 22000163843072

当查询已确定要读取 amount 的 Row 1500 时,可以通过行号索引定位 Page 1,再用 Offset 和 Size 读取对应字节区间。读取后仍需解压、解码,并取得 Page 内对应行的数据。

4. Page 是否有序,如何定位和扫描

4.1 “顺序存储”不等于“按字段值排序”

Data Page 内的数据按 Row Ordinal 对应的逻辑行序排列,但字段值不一定有序。

例如:

DUPLICATE KEY(order_id)
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 的细节

DUPLICATE KEY(create_date, customer_id)

排序规则是组合键 (create_date, customer_id) 的字典序,不是 customer_id 全局单调:

create_datecustomer_id
2026-11-01100
2026-11-01200
2026-11-0250
2026-11-02150

create_date 整体有序;customer_id 仅在相同 create_date 的组内有序。

4.3 找到 Page 后是不是必须遍历全部数据?

如果 Page 中的目标列无序,而且没有更精细的可用索引或候选行号,那么通常要检查候选 Page 内的值。

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 前缀与行位置缩小候选行范围
ZoneMapSegment / Column Data Page 等层级Min、Max、Null 等统计跳过不可能命中的数据区域
Ordinal Index单列 Data Page行号范围与 PagePointer按 Row Ordinal 定位 Page
倒排索引(显式创建)配置了索引的字段值或词项 → 候选行集合精确检索 / 文本检索等
BloomFilter(按配置)适用字段和数据块概率集合信息排除“不存在”的情况;存在假阳性

这些索引解决不同问题,能够组合使用。

5.2 Prefix Index:利用排序 Key 稀疏定位

DUPLICATE KEY(order_id, customer_id)

概念性索引:

Key 1000 → Row 0
Key 2000 → Row 1024
Key 3000 → Row 2048

查询:

SELECT * FROM orders WHERE order_id = 2500;

前缀索引先将候选范围缩小,再在排序 Key 数据中进一步定位,而不是保存“每个 Key 对应一条行记录”的密集索引。

Doris 2.1 的前缀索引使用排序 Key 前面的有限字节(常见上限为 36 字节);遇到字符串 Key 列时还有长度截断与后续列停止纳入等规则。它既不是每列都有的索引,也不是一般意义的全文索引。

对于 DUPLICATE KEY(order_id, customer_id):

WHERE order_id = 10001        -- 更利于使用前缀索引
WHERE customer_id = 20001     -- 缺少首列条件,难以高效定位

5.3 ZoneMap:Page 和 Segment 层面的 Min/Max 排除

假设 age 列:

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 的有效性取决于值的局部集中程度:

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

已知 Row Ordinal = 1500
    ↓
Ordinal Index(amount 列)
    ↓
Page 1 → offset=14336, size=2048
    ↓
读取 / 解压 / 解码该 Page,获取所需行

这里必须分开理解:

  • 逻辑定位:Row Ordinal → Data Page。
  • 物理定位:Data Page → Segment 中的 Offset + Size。

5.5 倒排索引:从值到候选行

对于无序列:

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 方案

示例:

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 读取

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;

可概念化为:

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 字节的字段:

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 个连续整数。

列式内存:
[amount0][amount1][amount2][amount3][amount4]...

与每行 500 字节、每次只需其中 8 字节的宽行扫描相比,连续列式访问通常:

  1. 带来更高的有用数据比例。
  2. 更有利于硬件预取。
  3. 减少无关字段占用缓存与内存带宽。
  4. 为向量化和 SIMD 处理准备紧凑数据布局。

也要注意:行式数据库的覆盖索引等技术可以避免回表;不能把上面的对比绝对化为“所有行存查询都读完整行”。

9. 编码与压缩为什么快

9.1 编码与压缩是两件事

写入 Data Page 时可以概念性地分成:

原始列值
  ↓
Encoding(字典、RLE、BitShuffle、FOR 等适用编码)
  ↓
Compression(如 LZ4F、ZSTD)
  ↓
压缩后的 Data Page → Segment

实际编码取决于类型、编码策略和版本,并非每个 Page 都用到所有算法。

字典编码(Dictionary Encoding):

原始: [CHINA, CHINA, USA, JAPAN, CHINA]
字典: 0=CHINA, 1=USA, 2=JAPAN
编码: [0, 0, 1, 2, 0]

当重复字符串很多时,把重复值替换成较小整数 ID 通常很划算。

RLE(Run-Length Encoding):

原始: [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。

未压缩读取:

1000MB / 500MB/s = 2.0s

压缩后读取再解压(串行上限示意):

读取: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 模型可概念化为:

Aggregate.next()
    Filter.next()
        Scan.next()  → 取一行
Aggregate.next()
    Filter.next()
        Scan.next()  → 再取一行
...

对上亿行数据,逐层调用、动态分派、分支以及逐行表达式处理可能产生很大额外开销。

10.2 Doris 按 Block 批处理

Doris 2.1 的向量化引擎使用列式 Block 传递数据:

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 行,约需:

ceil(100000000 / 4096) = 24415 个 Block

重要区别:算子间传递次数减少,并不表示 1 亿个值不需要被检查。收益来自批量循环、更少解释开销、连续访问、缓存友好以及可能的 SIMD 优化。

10.3 SIMD:单指令多数据

对于 8 个 INT32:

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 三者协同

列裁剪:只读取需要的列
  ↓
编码压缩:从磁盘读取更少字节
  ↓
解压解码:生成适合计算的列数据
  ↓
向量化 Block:减少逐行算子开销、改善缓存行为
  ↓
Filter / Aggregation:尽可能高吞吐地计算

一句话总结:少读取、少传输、快计算。

11. Compaction 如何影响存储与查询

反复写入可能在同一 Tablet 中形成大量 Rowset:

Tablet
  ├── Rowset A [1-1]
  ├── Rowset B [2-2]
  ├── Rowset C [3-3]
  └── Rowset D [4-4]

即使每个 Segment 内部遵循排序 Key,不同 Rowset 的 Key 范围仍可能相互重叠。

Rowset A: [100,200,300]
Rowset B: [150,250,350]
Rowset C: [120,220,320]

查询一个 Key,可能需要检查多个 Rowset。Compaction 会合并与重排数据,生成新的 Rowset 和 Segment,重建相应索引:

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 查询元数据

SHOW TABLETS FROM orders;
SHOW TABLET 10001;

查询系统表(字段是否齐备以当前 Doris 2.1.10 实例为准):

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 信息:

curl "http://BE_IP:8040/api/compaction/show?tablet_id=10001"

将 10001、BE_IP 和端口替换为实际环境信息;不同版本和权限配置可能影响接口是否可访问。

12.2 查看查询计划和 Profile

EXPLAIN
SELECT customer_id, SUM(amount)
FROM orders
WHERE amount > 1000
GROUP BY customer_id;
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/OBytesRead、压缩读取相关统计是否受磁盘与缓存影响
解压解码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 是瓶颈且压缩率较好时,减少读取往往抵消解压成本;如果数据已缓存、解码重且压缩收益低,压缩也可能拖慢查询。

最终串联

Table → Partition → Tablet → Rowset → Segment
                                     ↓
                        所有列逻辑上放在一个 Segment 内
                                     ↓
                         每一列独立切分 Data Page
                                     ↓
              Short Key / ZoneMap / Ordinal / Inverted Index
                                     ↓
                    定位候选行、Page 和文件 Offset
                                     ↓
                    按需读取 → 解压 → 解码
                                     ↓
                   Block 向量化过滤 / 聚合 / 返回

核心结论:

  1. 存储分布靠 Partition、Tablet;版本和增量写入靠 Rowset;物理列存靠 Segment、Column、Page。
  2. Prefix Index 利用排序 Key 定位,ZoneMap 利用范围统计跳页,Ordinal Index 用行号定位 Page;三者职责不同。
  3. Page 的行序有序不等于字段数值有序;无序 Page 没有更细索引时,仍然可能需要扫描全部候选值。
  4. Doris 分析查询高吞吐的基础是列裁剪减少无效读取、编码压缩降低字节量、向量化改善 CPU 执行效率。
  5. 真正优化生产查询,需要结合 表模型、Key 顺序、数据分布、Index 配置、Compaction 和 Query Profile 判断瓶颈。

14. Block:一批数据如何包含多列

Block 是 BE 向量化执行引擎中的内存批次,并不是 Segment 中的 Data Page。一个 Block 可以包含多列,各列通常有相同的逻辑行数,并以相同下标对应同一条记录。

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 的概念结构

// 讲解用简化结构,并非原样摘录 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 时,一批数据可以形成过滤掩码:

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 算子拆分等决定,不是所有查询都会依次调用这里的每一个接口。

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 范围,驱动列迭代器批量读取数据。

// 调用关系示意:并非可直接编译的完整源码
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() 根据结果缩小行集。

// 概念伪代码,展示两步职责
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。

SELECT customer_id, SUM(amount)
FROM orders
GROUP BY customer_id;

分组聚合一般维护 Hash Table,以 customer_id 查找或创建聚合状态,再把对应的 amount 累加进去。

// 讲解用伪代码
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 输出

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 调度细节:

  1. be/src/vec/core/block.h:Block 如何管理多列。
  2. be/src/vec/columns/column_vector.h:整数等列的内存表示。
  3. be/src/olap/rowset/segment_v2/segment_iterator.cpp:列数据批量读取。
  4. be/src/vec/exprs/vexpr_context.cpp:表达式批量计算。
  5. be/src/vec/core/block.cpp:Block 过滤。
  6. be/src/vec/exec/vaggregation_node.cpp:分组聚合。
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 实际结果为准。