← 文章 / 数据与数据库
spiraldb 2026/10/13 · 2026-10-13 22:20:52 · 34 阅读

Vortex:一种格式通吃任意形状的数据

这是某场演讲的配套文章,内容比我在台上能讲的时间更详细。 你的数据库里很可能就有这样的东西:存在 JSON 列里的 JSON 文档、UUID 列里的 UUID,或者塞进 BLOB 列里的几何数据。我们并不是故意这样存数据的。 分析型数据库过去只存放简单值的列:布尔值、整数、小数、字符串,偶尔加个时间戳。但现在放进数据库的数据早就不是这么简单了!一个数据库里可能同时装着原始图片、视频、1536 维 embedding,以及深层嵌套的 JSON 文档(可能包含上百个字段)。 不久之前,应用还得自己去解读这些复杂数据。如今数据湖和湖仓(lakehouse)为这类数据提供了自己的类型和操作,我们可以把它们和简单数据放在一起查询了。 但底层的列式文件格式却没跟上。以 Parquet 为例,虽然这些年陆续加入了对现代类型的支持,但这些类型仍然必须套进它预设的编码和存储布局里。像视频这种数据,表里可能就只放一个指向外部文件的 URI。 基于简单的存储模型确实让格式更容易实现和优化,但代价是:当现有编码或布局不合适时,仅新增一个逻辑类型解决不了问题。而且如果你想给 Parquet 扩展新类型或新编码,就得走一套冗长的规范变更流程,之后每种语言的独立实现(Java、C++、Rust、Go)都要各自实现一遍。 我们的主张是:一种格式可以适配任何形状的数据,同时保持快和小。证明就是 Vortex——一个可扩展的列式数据格式,用 Rust 构建,与 Apache Arrow 零拷贝兼容,在 Linux 基金会下开源。 Vortex 文件在很大程度上是自描述的,因此这个格式是可定制的。写入方可以自行决定那些在其他格式中被规范写死的东西(比如列和 chunk 如何嵌套),并把这些决定记录在文件里。你可以组合现有的布局,而无需为读取方编写新代码(前提是它支持文件的版本、编码和布局)。 Vortex 里几乎一切皆可扩展,包括它的编码、布局和逻辑类型。这意味着你不必说服所有人相信你的新类型或编码值得加入,不必等委员会先把特性标准化才能使用,更不必依赖一个自己都还没想清楚如何做版本管理的格式。 注意,读取方仍然需要你的代码才能理解这个扩展,但关键在于:你不用从零开始造一个新的文件格式。你还可以把扩展贡献回 Vortex。由于 Vortex 的各语言绑定共享同一套 Rust 实现,被接受的扩展不需要每种语言都再实现一遍。 Vortex 的可扩展性源自几个设计决策。接下来我们会跟踪一个数组在压缩和计算中的流转过程,然后看看如何添加自己的编码、存储布局和逻辑类型。 Vortex 的核心数据结构是数组(array)。你可以把数组想象成表中的一列:一串类型相同的值。 那么什么是"逻辑类型"?它告诉你数组里装的是什么类型的值,比如整数、字符串、时间戳。但它不会告诉你这些值在内存或磁盘上是如何布局的。 一个 32 位无符号整数数组只包含能放进 32 位的整数。不过,我完全可以选择把这些 32 位整数按 64 位存储(如果我非要浪费一半空间的话 🤷)。 更现实一点,如果我知道所有整数都在 0 到 255 之间,就可以把 32 位整数"位打包"(bitpack)成 8 位,从而获得 4 倍的压缩率。 Vortex 用一个叫 DType 的 Rust enum 来表示这种逻辑描述。上面例子中的数组,无论其值在物理上怎么存储,逻辑类型都是 DType。DType 有这些变体:




章节
介绍了 Vortex 的整型和浮点类型。 和 包含其他 结构,因此类型可以嵌套。空值约束也是 的一部分:可空字符串和不可空字符串是两种不同的逻辑类型。 变体持有 ,我们稍后在本文末尾会再讲它。 每个数组都携带一个 ,但它仍然没有说明这些值在物理层面是如何存储的。因此,同一个不可空的 数组可以有多种不同的物理形态! 我们曾在 中更详细地探讨过这一区分, 这里先给出一个高层次的概览。 数组的物理表示被称为其 。上述那个不可空的 数组,无论选择哪种物理编码,其逻辑值和 都保持不变。 Vortex 用不同的 Rust 类型来表示不同的编码。例如, 字典编码、run-end 编码和位打包分别对应 、 和 。
字段已简化。图中未展示 FastLanes 的字节布局;元数据和填充也省略了。
你可以把每种编码看作实现了同一个 trait,其中 用来隐藏其具体类型。下面的代码是一个简化的模型,并非 Vortex 的实际 API(更多信息见脚注)。 如果你不熟悉 Rust, 就是 , 它允许我们在不了解具体类型的情况下,使用实现了 trait 的对象(通过动态分派)。 关键在于,每种编码都自行提供该共享接口的一套实现。这样 Vortex 就可以把它当作一个 来传递,而不必把某个具体编码加到中心 enum 或 match 表达式里。 通常新增一种编码只需我们花几周时间(有时甚至只有几天!) ——这还是在 LLM 尚未能辅助实现代码之前。
Vortex 已经内置了 。 去看看我们的其他博客吧!
仔细观察图表,你或许会发现,字典(dictionary)的子节点 values 和 codes 同样是整数数组。这意味着我们可以用另一种编码来压缩每个子节点!字典能将重复的字符串替换为整数码值,而这些码值自身往往也具有某种规律。 以一个包含七个城市名、但只有两个不同值的列为例,分别是 "Pittsburgh" 和 "New York City"。字典只需存储一次这两个城市名,而每一行则持有一个小的整数码值来选取其中一个(即字典中的索引)。
虽然我们移除了重复的字符串,但字典中的码值数组是 "5, 1, 7, 0, 1, 0, 0",仍然包含三个连续段(runs)。由于码值本身也是一个数组,Vortex 可以将其编码为 RunEndArray(运行结束数组)。这会用三个结束位置 [3, 5, 7] 和每个连续段的一个值 [5, 1, 7],替代掉原来的七个码值。 每个结束位置是该连续段后紧跟的索引:第一个连续段占据第 0、1、2 行,因此其结束位置是 3。

结束位置是独占式的:结束位置 3 覆盖第 0、1、2 行。

码值: RunEndArray END VALUE ROWS 3 0 [0, 3) 5 1 [3, 5) 7 0 [5, 7)
七个字典码值 第 1/5 步
最大的连续段结束位置是 7,因此每个结束位置只需 3 位即可表示。连续段的值仅为 0 和 1,因此每个值只需 1 位。因此,Vortex 可以对这两个子节点同时进行位打包(bitpacking)。
对每个整数子节点进行位打包。每个连续段结束位置保留 3 位,每个连续段值保留 1 位。 END 十进制 8 位字 3 0000001 1 5 0000101 7 0000111 BitPacked<3> 011 101 111 VALUE 十进制 8 位字 0 0000000 1 0000001 0 0000000 BitPacked<1> 0 1 0

图示为 8 位输入,省略了打包元数据和填充。

两个整数子节点 第 1/5 步
编码后的数组现在成了一棵树!字典编码将原始字符串分解为 values 和 codes;运行结束编码(run-end encoding)进一步将这些 codes 分解为 ends 和 run values;位打包则压缩了这两个整数数组。
DictArray
  • values: ArrayRef 字符串值 Pittsburgh New York City
  • codes: ArrayRef RunEndArray
    • ends: ArrayRef BitPackedArray bit_width: 3 · 独占式结束位置 3 5 7
    • values: ArrayRef BitPackedArray bit_width: 1 0 1 0
与其让单一编码压缩整列数据,Vortex 可以在数组树的多个层级上组合多种编码。每一层都向下层编码暴露一个更简单的数据组件,让各编码相互配合,从而更好地压缩列。14 这种递归过程被称为级联压缩(cascading compression):选定一种编码后,压缩器会“级联”向下,对每个子数组重复这一过程。 Vortex 的压缩器通过对数据进行采样,自动构建这些级联结构,决定对数组应用哪种编码最为合适。其设计灵感来自 BtrBlocks 研究论文。15

#在压缩数据上直接计算

写入只是数据格式的一面。压缩虽然节省了存储和 I/O,但如果每次查询都要解压数组,往往意味着付出更多的 CPU 时间和内存。最坏的情况下,我们甚至可能解压并重建那些根本用不到的值。 不过,我们可以更聪明地处理这件事。编码通常能提供关于已压缩数据的有用信息,比如哪些值在重复、重复的频率如何。Vortex 可以利用这种隐含的结构,在数据仍处于压缩状态时就执行操作。

#RunEnd 的求和

最简单的做法是从求和整数数组开始: [10, 10, 30, 30, 30, 50, 50, 50, 50]。如果将其编码为 RunEndArray,其结束位置为 [2, 5, 9],值为 [10, 30, 50]。最直观的方法是解压整个数组,然后将这九个整数逐一相加。
先解压,再求和展开所有九个整数,然后逐个累加。RunEnd 输入结束位置259数值103050解压后的整数10103030305050505050累加0 + 10 =10 + 10 =20 + 30 =50 + 30 =80 + 30 =110 + 50 =160 + 50 =210 + 50 =260 + 50 =010205080110160210260310
游程结束输入播放第 1 / 14 步
但游程的结束位置本身已经告诉了我们每个数值重复了多少次!从 0 开始,用相邻的结束位置相减,即可得到游程长度 [2, 3, 4]。随后,专用计算内核可以将每个游程的数值乘以其长度并累加这些乘积:10 * 2 + 30 * 3 + 50 * 4 = 310。16
对压缩游程求和专用计算内核推导游程长度,乘以对应数值,并累加三个乘积。RunEnd 输入结束位置259数值103050游程长度与乘积
长度数值 × 长度
2 − 0 = 210 × 2 = 20
5 − 2 = 330 × 3 = 90
9 − 5 = 450 × 4 = 200
累加0 + 20 =20 + 90 =110 + 200 =020110310
游程结束输入播放第 1 / 7 步
在这个例子中,由于数据量较小,我们只节省了几次操作。但你可以想象,对于拥有超长游程的巨大列,这种优化带来的收益将是巨大的!

#与 Dict 对比

现在,假设我们要在原始七行城市数组中找到 city == "New York City" 的行。我们需要一个选择掩码,每行对应一个布尔值。朴素的方法是解压数组,然后比较这七个字符串。
先解压,再比较解码七个城市名称,然后逐个与 New York City 进行字符串匹配。Dict 输入数值0Pittsburgh1New York City编码0001100== "New York City"
行解码后的城市是否匹配?
0Pittsburghfalse
1Pittsburghfalse
2Pittsburghfalse
3纽约市true
4纽约市true
5匹兹堡false
6匹兹堡false

1 次字符串比较

2 次字符串比较

3 次字符串比较

4 次字符串比较

5 次字符串比较

6 次字符串比较

7 次字符串比较

选择掩码falsefalsefalsetruetruefalsefalse
字典输入播放步骤 1 / 10
Vortex 可以做得更好。它可以将未求值的操作表示为数组节点,并将其输入作为子节点。在这里,比较操作位于字典数组之上。 由于数组采用字典编码,Vortex 可以使用一条重写规则,将比较操作推入字典的 values 中。它只需要比较 "New York City" 与 "Pittsburgh" 以及 "New York City",从而生成 [false, true]。作为子节点的 codes(包含其下方级联的 RunEnd 和 BitPacked 数组)在比较过程中无需改变。17
比较字典值重写规则将谓词推入 values,然后使用未改变的 codes 来筛选布尔值。city == "New York City"字典输入Values== "New York City"0Pittsburghfalse1New York Citytrue

2 次字符串比较

Codes0001100

逻辑 codes;RunEnd -> BitPacked 保持不变。

布尔查找表
行编码匹配?
00false
10false
20false
31true
41true
50false
60false
选择掩码falsefalsefalsetruetruefalsefalse
对 Dict 应用谓词第 1 步 / 共 11 步
[false, true] 告诉我们哪些字典值匹配,但我们还需要知道哪些行匹配。每行的 code 会从这些布尔值中选取一个:code 0 选取 false,code 1 选取 true。套用原始的 codes,就得到选择掩码 [false, false, false, true, true, false, false]。七行数据只省了五次字符串比较,但如果有 100 万行而字典只有 d 个值,Vortex 就只需比较 d 个字符串!

#过滤 Dict

现在假设另一个查询给出了 city 数组的选择掩码 [false, true, false, true, true, false, true]。 我们可以先解压全部七个字符串,再丢弃掩码排除的那三行。
先解压再过滤先重建七个字符串,再保留掩码选中的四行。Dict 输入Values0Pittsburgh1New York CityCodes0001100解码后的字符串与行掩码
行解码后的城市掩码
0PittsburghPittsburghfalse丢弃
1Pittsburghtrue保留
2PittsburghPittsburghfalse丢弃
3New York Citytrue保留
4New York Citytrue保留
5PittsburghPittsburghfalse丢弃
6Pittsburghtrue保留
保留的字符串PittsburghNew York CityNew York CityPittsburgh
字典与选择掩码第 1 步 / 共 10 步
但 Vortex 可以改用另一条重写规则,把过滤下推到字典的 codes 上。 把掩码应用到 codes [0, 0, 0, 1, 1, 0, 0] 上,得到 [0, 1, 1, 0]。值得注意的是,执行这种选择过滤时,我们完全不需要动 values 子数组!18
过滤字典 codes重写规则把选择掩码下推到 codes 上,复用字典 values。Dict 输入Values0Pittsburgh1New York CityCodes过滤
行Code掩码
00false丢弃
10真,保留
20假,丢弃
31真,保留
41真,保留
50假,丢弃
60真,保留
结果:字典值匹兹堡纽约市筛选后的编码0110
字典与选择掩码步骤 1 / 9
这些都属于延迟物化:在数据仍被压缩时执行操作。19 我们关于计算下推的博客文章更详细地探讨了这种编码级别的下推。 Vortex 通过两种方式实现这些优化:专用计算内核直接在编码上运行操作,以及重写规则重组数组树。20 优化器会不断应用重写规则,直到数组树不再变化为止。21 规则首先检查数组是否满足其要求。如果没有适用的规则或内核,Vortex 可以将数组转换为规范形式(即其逻辑类型的普通表示形式),并在此处执行操作。22 我们将在下一节解释其工作原理。

#添加新的物理编码

我们前面介绍的编码格式在 Vortex 中都是默认内置的,但这并非强制要求。来自其他 crate 的第三方编码,通过同样的插件接口即可接入,和 Dict、RunEnd 或 BitPacked 完全一致。归一化(Canonicalization)的作用,是把某种逻辑类型对应的各种物理编码收敛成一种统一的规范形态,而 Vortex 的算子已经知道如何处理这种形态。也就是说,我们只需为新编码实现归一化,让基本算子先跑起来,然后再追加专用 kernel 来提升性能。一个数组的 execute 方法负责把它逐步推向规范形态。以 Dict 为例,解压的过程就是拿每个 code 从字典里取出对应值。简化后的伪代码大致如下: Rust
// 执行到 “规范”编码形态,所有模块都知道怎么处理它。
fn execute(dict: DictArray) -> CanonicalArray {
    dict.codes.map(|code| dict.values[code]).collect()
}
这就给所有算子提供了一条兜底路径。如果 Vortex 没有针对某编码的专用计算路径,就调用 execute 一路推到规范形态,再继续执行。23 接着,你可以把该编码注册到一个 *session* 里。session 负责管理 Vortex 可用的编码及其余扩展能力: Rust
session.arrays().register(MyEncoding);
当 Vortex 读文件时遇到该编码,就会查这份注册表。24 你还可以为你想优化的操作注册专用计算 kernel;其余一切操作都会自动走上面的规范兜底,直接可用。 当然,注册编码只是最轻松的一步:子数组校验、元数据序列化、让压缩器知道何时选用该编码、优化计算等,都还得你自己来做。这些逻辑都可以放在你自己的 crate 里(读文件的一方需要引入该 crate),不必往某个中心 enum 里加新类型,也没必要 fork Vortex 的仓库。

#Adding a new storage layout

到目前为止,我们的 city 数组一直完全存在于内存中。我们把它压缩成一棵由 Dict、RunEnd 和 BitPacked 数组组成的树,并在不解压缩的情况下直接在这棵树上执行操作。但最终,这些字节总得存到某个地方去。 关于存储布局及其取舍,我们在 Data Layouts: Where Bytes Find Their Forever Home 一文中有更详细的讨论。这里只对 Vortex 如何组合和扩展这些布局做一个高层概述。 最朴素的做法是把整张表序列化成一个大的 buffer(我们用 StructArray 来表示多列)。Vortex 把这种方式称为 FlatLayout:一个 segment 里放一个序列化后的数组。假设我们只需要 city 表中的几行数据——由于给读取端的只有一个 segment,我们仍然得把整张表取回来加载。 Layout 描述了 Vortex 如何把数据切分成块。你可以把 Layout 理解成一个数据尚未加载进内存的 Array。和 Array 一样,它有 dtype 和子节点,同样构成一棵树。但它的叶子节点指向本地文件、内存缓存或 S3 对象中的 segment。这样,读取端就可以按需获取查询所需的特定 segment,而不是整个文件。25 于是,Vortex 有两种树:Array 树和 Layout 树。Array 树用于组合 Dict、RunEnd 这类编码;而要改变哪些字节被一起读取,则需要调整 Layout 树。Row group、column chunk、page 和 zone map 都可以通过 Layout 来实现。26
逻辑表
rowcityid
0Pittsburgh1
1Pittsburgh2
2Pittsburgh3
3New York City4
4New York City5
5Pittsburgh6
6Pittsburgh7
请求城市 · 行 0、1、2 已获取 未获取 平面布局 平面布局 整表 ↓ 分段 · 已获取 城市 · 行 0–6 ID · 行 0–6 布局树
  • 城市 分块
    • 行 0–2 平面 ↓ 分段 · 已获取 城市 · 行 0–2
    • 行 3–6 平面 ↓ 分段 · 未获取 城市 · 行 3–6
  • ID 平面 ↓ 分段 · 未获取 ID · 行 0–6
分段大小仅为示意图。
Vortex 默认提供 Chunked、Struct 及其他几种布局,我们可以将它们组合以创建自定义的磁盘数据存储布局。例如,通过组合 Chunked、Struct 和 Flat 布局,如果我们愿意,完全可以精确复现 Parquet 的 PAX 式“行组 -> 列块 -> 页”层级结构27。 布局的可组合性意味着我们可以为 Vortex 存储的数据定制 I/O 和存储方式。例如,S3 对象和本地文件可能并不适合相同的存储布局,因此某个 crate 可以为不同的存储系统或访问模式定义并注册相应的布局,而无需更改逻辑类型(或其内部任何编码)28。 在调整存储布局时存在诸多权衡。更小的分段可以提高剪枝效率和随机访问性能,但会增加元数据和 I/O 开销。过去一年半里,我们大幅优化了 Vortex 的布局,该主题内容庞大,无法在此详尽阐述,我们将在后续文章中继续深入探讨。

# 添加新的逻辑类型

现在我们可以决定数组在内存中如何压缩,以及它在磁盘上如何组织。然而,若缺少另一层抽象,Vortex 仍将 1536 维嵌入向量视为普通的浮点 FixedSizeList。这种区别很关键,因为向量本身有特定的合法取值范围和专属操作。如果 Vortex 只看到一串浮点数,上层应用就得各自负责强制这些约束。 这与把 JSON 存进 TEXT 列面临的问题一样:数据本身“塞得进去”,但列类型并未告知系统这些值必须是合法 JSON。同理,嵌入向量也能塞进浮点列表,但系统并不知道哪些操作适用于 Vector 类型。 Extension 数据类型让我们为 Vortex 的现有类型扩展出新的语义。可以把 Vector 定义为一个基于 FixedSizeList 存储的逻辑扩展类型,并附加专属的不变量和操作。例如,Vector 只接受元素为非空浮点数的定长列表(我们显然不想让向量里混进一堆 Utf8 值!)。借助 ExtVTable 特性,可以赋予该类型一个 ID,并校验其存储结构是否符合预期。下面是(高度)简化的代码示例:29 Rust
impl ExtVTable for Vector {
    fn id(&self) -> ExtId {
        ExtId::new("vortex.tensor.vector")
    }

    fn validate_dtype(dtype: &ExtDType<Self>) -> VortexResult<()> {
        let DType::FixedSizeList(element, ..) = dtype.storage_dtype()
        else {
            return error("storage must be a fixed-size list");
        };

        if !element.is_float() || element.is_nullable() {
            return error("elements must be non-nullable floats");
        }
        Ok(())
    }
}
这个 ID 告诉 Vortex,该扩展类型是一个 Vector。Vortex 底层仍沿用现有的列表和浮点编码,但查询引擎看到的是一个 Vector,而不是普通的列表。
Logical typeVector · 3 dimensionsStorage typeFixedSizeList3 non-nullable F32 elements per rowrow 01.52.53.5row 11.52.53.5Physical encodingDictArrayvalues: ArrayRef · F321.52.53.5codes: ArrayRefBitPackedArrayrow 0012row 1012packed: Buffer · 2 bits per coderow 0000110row 1000110
图中比特仅为示意,元数据和填充已省略。
然后就可以在会话中注册该类型: Rust
session.dtypes().register(Vector);
同一个 crate 还可以为该类型提供操作。例如 vortex-tensor 就向会话注册了余弦相似度、内积和 L2 范数等标量函数。 vortex-spatial 对 Polygon 等地理空间类型也采用同样的方式,提供的操作包括 contains、distance 和 intersects。Vector 和 Polygon 都定义在各自的 crate 中,无需向 Vortex 中央的 DType 枚举添加新变体。 我们也把这些扩展点用在了最初提到的那些更复杂的类型上。在闭源数据库 SpiralDB 中,我们基于 Vortex 实现了视频、图像和地理空间类型。我们的视频深度解析详细介绍了如何利用视频的内部结构,只获取并解码查询所需的帧。

#One format for any shape

如果你的数据需要 Vortex 未内置的类型、编码或存储布局,可以在自己的 crate 中提供扩展。读取端必须引入该 crate 才能使用这些扩展,但你无需 fork 容器格式本身。原始图像与视频、1536 维嵌入、深度嵌套的 JSON 文档、多边形、稀疏数据、重复值以及重复序列,都能存放在同一个格式内。逻辑类型可以描述复杂的值,编码则能表达值中的不同模式,包括前文提到的 `Dict -> RunEnd -> BitPacked` 嵌套结构。针对 S3 上的大表,布局设计可以仅获取查询所需的片段。 经历了所有这些扩展点之后,你可能会认为 Vortex 会为灵活性付出高昂的开销代价。但 Vortex 在数组粒度上进行调度,因此计算内核仍然是逐个向量地处理整个向量。正如前文所述,直接在压缩数据上操作还能避免先解压再处理所需做的额外工作。 我们的基准测试显示,Vortex 的压缩大小与 Parquet 相当,但写入、扫描和随机访问速度均显著更快。测试套件还包含 Lance 和 Arrow IPC:在高频随机访问场景下,Vortex 的表现优于两者,同时生成的文件体积要小得多。虽然结果因工作负载和查询引擎而异,但 Vortex 的灵活性为超越 Parquet 留下了充足的余地。 Vortex 提供 Rust crate 和 Python 包两种形式,文档位于docs.vortex.dev。请查阅代码仓库,如果有兴趣使用 Vortex,欢迎联系我们!

#Footnotes

  1. 主流分析平台都在朝这个方向演进,复杂数据类型已拥有专属的类型系统: ↩
  2. Apache Arrow 的 格式介绍展示了同一张表在内存中按行和按列布局的对比,文件也是同样的道理。↩
  3. Parquet 有八种物理类型,逻辑类型在这些基础类型之上附加语义。例如 JSON 使用 BYTE_ARRAY,甚至 VARIANT 也把结构隐藏在 二进制编码背后:在不做 shredding 的情况下,它把 value 和 metadata 存成两个 BYTE_ARRAY 字段;shredding 则允许把值的部分内容拆到带类型的列中。Parquet 还把定长列表存成普通的 LIST,因此 Arrow writer 只能在 ARROW:schema 元数据里保留原始类型。参见 Parquet 的 物理类型、 逻辑类型,以及尚未落地的 FIXED_SIZE_LIST 提案。↩
  4. Parquet 通过邮件列表讨论和投票来增加新特性,旧版本 reader 无法解码新编码。参见 Parquet 的 格式版本文档。↩
  5. 每种 Vortex 逻辑类型都对应一个 canonical encoding,每个 canonical encoding 又映射到一种 Arrow 类型。只要两者布局一致,转换时就能直接复用底层 buffer。 canonical encoding 的设计说明解释了我们为何选择这些表示方式,双向转换则由 vortex-arrow crate 完成。↩
  6. 经过数月 讨论,Parquet 社区 投票决定 使用主版本号来标记旧版读取器无法兼容的变更。不过,投票结果将具体实现细节留待一份单独的 工作文档 处理,其中部分决策仍在争议中。↩
  7. Vortex 的 语言绑定指南 描述了一个包含四个层级的支持体系,从读写 Arrow 数据到在当前语言中注册插件。 Python、 C、 Java 和 DuckDB 绑定 均封装了相同的 Rust 库。↩
  8. 上述 4x 的数据未计入数组元数据。Vortex 采用了 FastLanes 比特打包算法, 该算法以 1,024 个值为单位进行处理,以便利用 SIMD 高效解包。由于最后一个块会被填充至 1,024 个值, 短数组的压缩率可能不如单纯根据比特位宽预测得那么好。↩
  9. 此处我们简略展示了完整的 DType 枚举。你可以在 PType 中找到全部十一种整数和浮点数位宽。↩
  10. 在实际 API 中,编码需实现 VTable 及其相关 trait,用以定义编码的行为。Vortex 基于这些实现派生出内部的私有分发层。 ArrayRef 封装了 Arc<ArrayInner<dyn DynArrayData>>,这是一个单一的 16 字节胖指针。我们可以直接读取长度、dtype 和编码 ID 字段,无需进行虚函数调用。我们也以命名字段的形式画出了子数组,但实际 API 中使用的是索引槽位。有关 VTable 与分发 的更多细节,请参阅相关指南。 ↩
  11. 如果你用过 arrow-rs,这个简化模型可能很眼熟。其 ArrayRef 正是 Arc<dyn Array>。DataFusion 的物理计划也有相同结构:每个算子实现 ExecutionPlan,计划将子节点存储为 Arc<dyn ExecutionPlan>。Vortex 以不同方式封装数组,但核心思想一致:调用者使用共享接口,无需知晓背后的具体类型。 ↩
  12. 作为对比,Parquet 的 ALP 规范 PR 花了近五个月才合并,而 FSST 支持目前仍只是提案。 ↩
  13. Run-end encoding 存储的是每段游程的结束位置而不是长度,这样就能用二分查找定位包含指定行的游程。Apache Arrow 的 Run-End Encoded layout 也做了同样的选择,Vortex 可以把 Arrow 的 run-end 数组直接 导入为 RunEndArray。 ↩
  14. 你可能会注意到这有点像查询执行计划。Vortex 借鉴了很多相同的思路,但范围更小:它只求值数组操作,比如标量函数和过滤,不涉及排序、连接这类关系代数算子。在设计 Vortex 的执行模型时,我们从经典查询引擎中获得了不少灵感。 ↩
  15. 压缩器的 概览文档 介绍了它如何选择编码。每种压缩方案先检查自己能否处理数组的规范化形式,再估算压缩效果,通常是通过对约 1% 的值采样压缩来估计。级联最多三层,同一条链中不会重复尝试同一种方案。注册一个编码并不会让压缩器自动学会选用它,你可以提供自己的压缩方案,并通过 compressor builder 添加进去。 ↩
  16. RunEndSumKernel 首先将 ends 和 values 子节点解析为基础数组,随后即可在不展开 run 的情况下直接求和。sum_all_valid 负责执行示例中的算术操作:通过减去连续的 ends 得到每个 run 的长度,乘以该 run 的值,最后累加这些乘积。该内核被注册为 RunEnd 的聚合内核。↩
  17. 比较运算下推由DictionaryScalarFnValuesPushDownRule 实现。它将标量函数应用于 values,并复用现有的 codes。如果该函数可能失败,我们仅在 Vortex 确认所有字典值都被使用时才执行此操作,以避免查询因引用不到的值而失败。↩
  18. 字典过滤实现将选择掩码传递给 codes,并复用现有的 values 数组。该过滤规则被注册为重写规则。这类似于查询引擎中的过滤下推:在查询引擎中,我们移动过滤条件以尽早丢弃行;在此处,我们移动过滤条件通过编码树以避免重建字符串。↩
  19. 这个术语源于列式数据库的研究。Abadi、Myers、DeWitt 和 Madden 在 ICDE 2007 会议上发表的论文《列式 DBMS 中的物化策略》(Materialization Strategies in a Column-Oriented DBMS)对比了提前重建行与等待过滤器运行后再重建这两种做法。Vortex 将这一思想下移了一个层级:它作用于编码内部,而非跨查询执行计划。↩
  20. Vortex 的 ExecuteParentKernel 接口允许某种编码在父节点中执行操作,我们称之为融合执行。例如,bitpacking 的融合比较内核在解包数值的同时,将每个包含 1,024 个值的块与常数进行比较,并直接将结果写入位掩码,无需构建整数中间数组。聚合操作使用独立的内核接口,但也可以直接作用于编码之上。↩
  21. try_optimize 循环试图简化各个节点及父子节点对,直到没有进一步变化为止。其中设有 101 次迭代的限制,以防止规则之间反复抵消彼此的优化效果。↩
  22. 每个 DType 都有且仅有一种标准编码,列在 Canonical 枚举中。字符串和二进制数据采用 Arrow 的字节视图(有时被称为德语字符串)作为其标准形式。与基于偏移量的数组相比,这种形式过滤速度更快,但偶尔需要垃圾回收。↩
  23. 字典编码的数组分阶段执行。首先把 codes 执行成 primitive array,再把 values 执行成规范形式,然后调用 take_canonical(values, codes) 为每个 code 查找对应的字典值(大致相当于 output[i] = values[codes[i]])。一次 execute 调用不必一步到位,但必须让数组更接近规范形式。具体实现可以看 VTable::execute、Dict::execute 和 take_canonical。 ↩
  24. 你可以让 Vortex 读取未知的 encoding,但它只能把结构保留为占位符。要解码数据或进行计算,读取方仍然需要该 encoding 的代码。参见 SerializedArray::decode。 ↩
  25. 读取器会为每个 segment 向 SegmentSource 发起请求,segment 的来源可以是文件、对象存储、缓存或内存缓冲区。 FlatLayoutStrategy 负责序列化一个数组,并将其 buffer 作为单个 segment 写入。文件中除了存储这些 segment 外,还包含序列化的布局树以及用于定位它们的 footer 元数据。 vortex-file 概述 展示了这些组件是如何协同工作的。魔术字节 VTXF 定义在名为 forever_constant 的模块中,并有一个名为 never_change_these_constants 的测试对其进行保护,以确保这些常量不会被意外修改。↩
  26. Zone map 对应 Zoned 布局。它包含一个数据子节点和一个 zones 子节点,后者存储每个 zone 的一行聚合统计信息。在扫描过程中,Vortex 会利用这些统计信息检查某个 zone 中是否存在可能匹配过滤条件的行。如果能排除整个 zone,则会跳过读取该 zone 的数据。↩
  27. 最初的 PAX 论文 阐述了 Parquet 文件层级结构 背后的存储模型。Vortex 的 内置布局 提供了构建 类似层级结构 所需的基础组件。 WriteStrategyBuilder 则是用于配置写入器如何组织文件布局的地方。↩
  28. 要添加一种布局,你需要分别实现一个用于读取的 VTable 和一个用于写入的 LayoutStrategy,然后将该布局注册到 会话注册表(session registry)中。若允许未知布局,Vortex 可以将其作为占位符保留,但其 读取器将返回错误。↩
  29. 在实际代码中, validate_vector_storage_dtype 执行上述检查。我们用伪代码列出了这些检查,以便你能看清构成有效向量的条件。完整的 ExtVTable 还处理元数据和标量值;你可以在 Vector 实现 及其 会话注册中看到这一点。如 ExtVTable 文档所述,扩展数据类型(extension dtype)包裹一个存储 DType 并附加元数据。它在不定义新的物理数组布局的前提下,赋予了数据新的含义。↩
原始来源: spiraldb

评论 (0)