Dosi vs MetricFlow vs Cube¶
2026-09-03 的三方对比:dosi / dosi-server 0.1.8、MetricFlow 0.212.0(dbt-metricflow 0.14.0)、Cube Core 1.7.33(Tesseract 规划器)。共 24 个查询,分六档(基础、过滤与排序、JOIN、时间窗口、派生指标、参数),三种数据规模(1,820、100 万、1,000 万条 bookings)。
方法¶
三个引擎用的是同一份语义模型(各自原生写法,取自 MetricFlow simple_model 的五个数据集:bookings、views、revenue、listings、users)、同一份灌好的 DuckDB 数据和同样的查询。每个引擎都通过它自己发布的程序来跑:dosi 与 dosi-server、mf、cubejs-server。计时之前,先校验每个查询在三个引擎上的结果完全一致,24 × 3 个结果在每种数据规模下都对上了。
| 形态 | dosi | MetricFlow | Cube |
|---|---|---|---|
| 冷启 CLI | dosi query,每个查询一个进程 |
mf query --explain / mf query,每个查询一个进程(MetricFlow 不提供服务端) |
— |
| 冷启服务 | dosi-server 启动 → 第一个执行请求返回 |
— | cubejs-server 启动 → 第一个 /v1/load 返回 |
| 热态编译 | POST /v1/query/compile |
— | POST /cubejs-api/v1/sql |
| SQL 地板 | 各引擎生成的 SQL 原样在 DuckDB 里跑 | 同左 | 同左 |
| 并发 | k 个闭环 keep-alive 客户端,查询互不相同 | k 个并行 mf query 进程 |
k 个闭环客户端 |
| 模型规模 | dosi validate、dosi query、服务启动 → 第一次编译 |
dbt parse、mf query --explain |
启动 → 第一个 /v1/sql |
环境¶
- AWS EC2,4 vCPU Intel Xeon Platinum 8259CL @ 2.50GHz,15 GiB 内存,Linux 6.1(al2023),与其他常驻服务共用
- dosi 0.1.8 发布版二进制,进程内 DuckDB
- MetricFlow 0.212.0、dbt-core 1.12.3、dbt-duckdb 1.11.0、CPython 3.12
- Cube Core 1.7.33、Node 22,dev 模式,
CUBEJS_TESSERACT_SQL_PLANNER=true,未启用预聚合
结果¶
| dosi | MetricFlow(mf CLI) |
Cube | |
|---|---|---|---|
| 热态编译,未见过的查询 | 0.3–0.5 ms | — | 21–32 ms |
| 单个查询,冷启进程(编译) | 18–20 ms | 2.9–3.1 s | — |
| 服务冷启 → 第一个查询 | 47–59 ms | — | 2.3 s |
| 每个请求的引擎开销,100 万行(上界) | 4–10 ms | — | 36–90 ms |
| SQL 地板,窗口/偏移类查询,100 万行 | 7–12 ms | 20–62 ms | 209–343 ms |
| SQL 地板,一个请求里五个窗口,100 万行 | 12 ms | 202 ms | 1,511 ms |
| 16 个客户端时的吞吐,滚动窗口,100 万行 | 57 q/s | 1.0 q/s(16 个进程) | 2.9 q/s |
| 200 个数据集 / 3,000 个指标时的冷启 | 0.44 s | 6.5 s(dbt parse + mf) |
9.3 s |
| 1,000 万行:最近 60 天窗口,热态执行 | 129 ms | 5.0 s(冷启 CLI) | 3.4 s |
| 1,000 万行:一个请求里五个窗口,热态执行 | 128 ms | 5.0 s(冷启 CLI) | 28.4 s |
| 峰值 RSS,100 万行热态循环之后的服务端 | 284 MB | 每个 CLI 进程 172–380 MB | 1,021 MB |
24 个查询上,dosi 的热态编译比 Cube 快 37–78 倍。1,820 行、1 到 64 个并发客户端时,dosi 的每秒查询数是 Cube 的 12–46 倍,且没有出错。
这些数字说明什么¶
- 引擎开销大约 1 毫秒。 当几个引擎要数仓做的是同一件事(普通聚合、JOIN、过滤),各自生成的 SQL 运行时间相差在 ±10% 以内,剩下的就是引擎开销:dosi 约 1 ms,Cube 25–35 ms,MetricFlow 光进程启动就要约 3 s。
- 差距在生成的 SQL 上。 每个时间窗口、偏移和参数化查询,几个引擎让数仓做的事并不一样。100 万行时 dosi 的 SQL 快 5–130 倍,而且数据越大差距越大:1,000 万行时,一个带五个窗口的请求 dosi 要 128 ms,Cube 要 28.4 s。
- 并发随核数扩展。 客户端越多,dosi-server 的吞吐越高;Cube 会把请求排队,MetricFlow 每个查询都要一个进程。
- 模型规模几乎没影响。 dosi 加载 3,000 个指标用 0.44 s,另外两个要 6.5–9.3 s。
注意事项¶
- 单台共用的 4 vCPU 机器。结论看比值,不看毫秒的绝对值。
- 引擎开销那一行是上界:计时的请求带了一个破缓存的谓词,SQL 地板那次运行没有。
- dosi 的四个滚动与累计用例扫了全表,另外两个引擎只扫 60–90 天,这几行对 dosi 不利。
- 没有用 Cube 的预聚合;Cube 跑在 dev 模式。一次生产模式的抽查表明,Cube 在这里慢并不是 dev 模式造成的。
- MetricFlow 只测了冷启,因为它就是这么发布的;dbt Cloud 的服务层闭源,没有测。
基准测试:Dosi vs MetricFlow¶
早先 dosi CLI 与老的 MetricFlow 引擎的两方同口径对比。下面的数字来自 2026-07-11 那次运行,已被上面的三方对比取代。
方法¶
两个引擎处理的是同一份语义模型(MetricFlow 自带的 simple_model 测试模型,
1:1 转成 Apache Ossie),跑的是同样的查询,打在同一个灌好数据的 DuckDB 库上。
这些查询在 CI 里已经核对过两个引擎返回的结果集完全一致,
所以这个基准测的是等价工作量的速度。
| 测量项 | Dosi | MetricFlow |
|---|---|---|
| 冷启 CLI | 一个 dosi query 进程:启动 → 加载模型 → 编译 → 打印 SQL |
一个 python 子进程:解释器启动 + import + 模型解析 + MetricFlowClient.explain()。与 mf query --explain 做的是同样的事,但不含 click/config 开销(这是一个偏向 MetricFlow 的界) |
| 热态 API | 同样是完整进程调用(osi 没有常驻模式;纯进程启动的下限单独报告) | 一次预热调用之后的进程内 explain() 循环,解释器、import 和模型解析的代价都已付过 |
| 执行 | dosi query --execute --db <file>(冷启,完整进程) |
进程内 query() 循环(热态)以及冷启子进程 |
| 峰值 RSS | 冷启子进程的最大常驻集大小(wait4 的 rusage) |
同左 |
冷启轮次按 A/B 交错进行,丢弃 1 次预热后计时 5 次;热态循环 30 次迭代。报告中位数。
环境¶
- 2026-07-11,dosi-engine
f850dfd,cargo build --release - AWS EC2,4 vCPU Intel Xeon Platinum 8175M @ 2.50GHz,15 GiB 内存,Linux (al2023)
- MetricFlow:Datus fork,可编辑安装,CPython 3.12.12(uv venv)
- DuckDB CLI v1.4.4,灌入
simple_model的测试数据
结果¶
osi 的进程启动下限(dosi --version):中位数 2.0 ms。
SQL 编译 —— 冷启 CLI(进程启动 → 打印出 SQL)¶
| 查询 | dosi | MetricFlow | 加速比 |
|---|---|---|---|
| simple_agg_by_dim (bookings ⟨is_instant⟩) | 10.6 ms | 2,321.9 ms | 220x |
| three_metrics_no_dim | 10.1 ms | 2,403.5 ms | 237x |
| ratio_metric (booking_fees_per_booker) | 10.4 ms | 2,309.2 ms | 222x |
| expr_metric (views_times_booking_value) | 10.4 ms | 2,338.8 ms | 226x |
| simple_agg_by_time (bookings ⟨ds⟩) | 10.5 ms | 2,289.9 ms | 219x |
MetricFlow 的冷启动构成:在任何查询开始编译之前,约 1,004 ms 的 import + 约 742 ms 的模型解析 + 约 161 ms 的客户端初始化,每次 CLI 调用约 1.9 秒固定开销。 dosi 付出约 2 ms 的进程启动,并在剩下的约 8 ms 里完成模型解析。
SQL 编译 —— 热态 API(一切都已驻留)¶
| 查询 | dosi(完整进程) | MetricFlow(进程内) | 加速比 |
|---|---|---|---|
| simple_agg_by_dim | 10.6 ms | 107.6 ms | 10.2x |
| three_metrics_no_dim | 10.1 ms | 218.9 ms | 21.6x |
| ratio_metric | 10.4 ms | 105.3 ms | 10.1x |
| expr_metric | 10.4 ms | 205.0 ms | 19.8x |
| simple_agg_by_time | 10.5 ms | 111.4 ms | 10.6x |
这是对 MetricFlow 最宽容的一种比法:它的数字是纯进程内编译时间, import 和模型解析的代价都已付过,而 dosi 仍是在全新进程里 重新读取、重新编译了一切。即便如此,dosi 依然快 10–22 倍。
DuckDB 上的端到端执行(编译 + 运行 + 打印结果行)¶
| 查询 | dosi 冷启 | MF 冷启 | 加速比 | MF 热态(进程内) | 对比 dosi 冷启 |
|---|---|---|---|---|---|
| simple_agg_by_dim | 34.2 ms | 2,321.1 ms | 68x | 127.0 ms | 3.7x |
| three_metrics_no_dim | 36.2 ms | 2,428.1 ms | 67x | 233.1 ms | 6.4x |
| ratio_metric | 35.7 ms | 2,368.8 ms | 66x | 122.7 ms | 3.4x |
| expr_metric | 33.5 ms | 2,441.2 ms | 73x | 235.9 ms | 7.0x |
| simple_agg_by_time | 32.9 ms | 2,309.1 ms | 70x | 132.8 ms | 4.0x |
加上执行之后,DuckDB 的查询时间(经 CLI 外调约 20 ms,两个引擎工作量相同) 成了共同的下限;即便如此,osi 的端到端冷启运行仍比 MetricFlow 的热态进程内 通路快 3–7 倍。
峰值内存(冷启进程,最大 RSS)¶
| 模式 | dosi | MetricFlow |
|---|---|---|
| 编译 | 约 15.5 MB | 约 157 MB |
| 执行 | 约 26.5 MB | 约 162 MB |
注意事项¶
simple_model很小(约 25 个数据集/指标)。MetricFlow 那约 742 ms 的模型解析 会随模型规模增长;而 osi 整个 10 ms 的预算里已经包含了它自己的解析。- MetricFlow 的"冷启"通路跳过了真实
mfCLI 的 click 启动和 Datus 配置解析, 所以真实的mf query调用会比这里测得的更慢一些。 - 时间维度那个用例的 group-by 写法不同(MF 用
ds,osi 用bookings_source.ds), 语义上是同一条查询,只是各用各引擎的原生语法。 - 数字来自单机(共享的 EC2 机器),请把相对比值而非绝对耗时当作结论。
Arrow IPC vs JSON:结果序列化¶
对于同一条查询,列式出口通路(POST /v1/query/execute 带
Accept: application/vnd.apache.arrow.stream,见
rest-api.md)相比默认的 JSON body
能省下多少。
这个基准会生成一个高基数的合成 DuckDB 数据集
(500 万行事实表,20 万个不同的 user_id)和一份配套的 Ossie 模型,
针对它们启动 release 版的 dosi-server,并让每个结果集分别走两种 Accept 格式。
方法¶
一个运行中的服务、一条查询、两个 Accept 头,唯一变化的只有响应编码。
每种格式测三项:
| 测量项 | 它反映什么 |
|---|---|
| wire MB | HTTP 响应体的字节数(中位数) |
| e2e ms | 从发出请求到收完整个 body 的墙钟时间:查询执行 + 服务端序列化 + 传输(中位数) |
| parse ms | 客户端把原始 body 变成可用结构的开销:json.loads 对比 pyarrow.ipc.open_stream(...).read_all()(中位数) |
500 万行表上的查询执行在两条通路上是完全相同的工作量, 所以它在 e2e ms 里构成一个共同下限(可以用 SMALL 那一行隔离出来, 那里载荷极小、序列化可以忽略)。wire MB 和 parse ms 没有共同下限, 是纯粹的格式成本。三种结果规模说明优势随结果放大,而不是随扫描量放大。 每个单元格 2 次预热 + 7 次计时运行,报告中位数。
环境¶
- 2026-07-14,dosi-engine
2e23173(工作树版本),cargo build --release - AWS EC2,4 vCPU Intel Xeon Platinum 8259CL @ 2.50GHz,15 GiB 内存,Linux (al2023)
- DuckDB CLI v1.4.4;客户端 CPython 3.9,pyarrow 21.0.0
结果¶
| 结果集 | 格式 | 行数 | wire MB | e2e ms | parse ms |
|---|---|---|---|---|---|
| SMALL —— 365 行 × 3 列 | JSON | 365 | 0.03 | 1483.5 | 0.3 |
| Arrow | 365 | 0.01 | 1463.1 | 0.2 | |
| LARGE —— 20 万行 × 3 列 | JSON | 200,000 | 10.63 | 2051.8 | 198.4 |
| Arrow | 200,000 | 6.50 | 1684.0 | 1.4 | |
| WIDE —— 20 万行 × 4 列 | JSON | 200,000 | 13.99 | 2749.3 | 242.7 |
| Arrow | 200,000 | 8.90 | 1707.9 | 2.0 |
读取大结果集时(Arrow 相对 JSON):
| LARGE(20 万 × 3) | WIDE(20 万 × 4) | |
|---|---|---|
| wire(网络上的字节数) | 小 1.6 倍 | 小 1.6 倍 |
| parse(客户端解码) | 约快 140 倍(1.4 对 198 ms) | 约快 120 倍(2.0 对 243 ms) |
| e2e(含共同的执行下限) | 快 1.2 倍 | 快 1.6 倍 |
| e2e 减去约 1.46 秒的执行下限(只剩序列化 + 传输 + 解析) | 约快 2.7 倍(221 对 589 ms) | 约快 5.2 倍(245 对 1286 ms) |
解读¶
- 解析是最大看点。 JSON 迫使客户端把每个值从字符串里重新解析出来, Arrow 交过来的是带类型的列缓冲区,解码开销基本为零 (20 万行 1–2 ms,对比 200–240 ms)。这个差距在 release 构建下也不会缩小, 它在客户端一侧,是结构性的。
- 序列化是服务端的收益。 去掉执行下限后,Arrow 花在格式本身上的时间 少约 2.7–5.2 倍:没有逐行物化,也没有逐值的 JSON 字符串编码, record batch 从执行器经 IPC writer 直接流进 body。行越宽差距越大 (WIDE > LARGE)。
- 收益随结果规模放大。 365 行时看不出差别,相对查询执行来说载荷只是舍入误差。 恰恰是结果很大的时候,才值得主动选择列式通路。
- 传输体积稳定在约 1.6 倍。真实部署可以在其上再叠加 HTTP 压缩, 解析和序列化上的收益与它无关。
注意事项¶
- 单机、回环传输(没有真实的网络 RTT 或带宽限制),所以 wire MB 低估了远程客户端能看到的传输时间优势,请把相对比值当作结论。
- 合成数据集以数值和短字符串为主。行更宽、字符串列更多时 JSON 的劣势会放大, 只有少数几个宽数值列时则缩小。
- e2e ms 每次请求都带着对全部 500 万行的 DuckDB 扫描(没有结果缓存)。 单独列出的"减去执行下限"那一行是对格式成本更干净的读数, 不过这个下限在不同 group-by 基数下也只是近似恒定。