用 Rust 从零搭一个时序数据库:编码不是存储层的事,是写入时的决定
前面分别写过列存与编码、向量化执行、WAL。但它们各自只解决了一段路:一篇讲"列怎么编码",一篇讲"批怎么算",一篇讲"日志什么时候 fsync"。
真正的问题是这三段怎么拼成一个数据库——能持续写入、能按时间范围查、能在重启后不丢数据。这篇把内存 SQL 引擎那套思路换一个场景重做一遍。
时序数据的形状,决定了整个架构
先把数据的形状说清楚,架构基本就是它的直接推论:
| 特征 | 数值 |
|---|---|
| 写入量 | 每秒几十万到几百万个点 |
| 查询量 | 每秒几个到几十个 |
| 更新/删除 | 几乎没有 |
| 写入顺序 | 基本按时间递增 |
| 查询形状 | 时间范围 + 标签过滤 + 聚合(avg/max/rate) |
| 点的大小 | 时间戳 8 字节 + 值 8 字节,通常只有几十字节 |
这张表里有三条硬约束:
- 写远多于读(典型是 1000:1)。所以写入路径上不能做重活——任何"每次写入都要重新组织数据"的设计都会死。
- 数据永远按时间追加。这使得"分段 + 段内有序"成为可能,而且不需要考虑原地更新。
- 查询从来不要原始点,只要聚合结果。所以"要不要预聚合"是一个可以主动做的决定,而不是只能被动响应。
整体架构:两条路径,一份数据
写入路径 查询路径
──────── ────────
DataPoint SQL / PromQL-ish
│ │
↓ ↓
WAL(顺序追加 + 定时 fsync) 查询规划
│ │ ① 时间范围 → 选出要读的段
↓ │ ② 标签过滤 → 位图
MemTable(列式,可查询) │ ③ 段级统计 → 剪枝
│ ↓
↓ 满了/到时间 段的解码(只解需要的列)
落盘成 Segment ────────────┐ │
│ │ ↓
↓ │ 向量化聚合
Compaction(合并小段) └──→ 段目录 ────→ 结果集注意两条路径共享的是"段"这个单位。 写入产出段,查询消费段。所以段的格式就是整个系统的接口——它同时约束了写入时能做什么编码、查询时能做多少剪枝。
这是这篇最想讲清楚的一件事:段格式的设计不是存储层的内部细节,它是写入和查询之间的契约。
第一步:数据模型——标签列和时间列是两个世界
时序数据一行长这样:
timestamp host region cpu_usage mem_used
2026-09-30T10:00:00 web-01 cn 0.73 1024
2026-09-30T10:00:01 web-01 cn 0.81 1031
2026-09-30T10:00:02 web-01 cn 0.79 1028pub struct Schema {
/// 时间列,永远是第一列
pub time: TimeColumn,
/// 标签列:字符串,低基数,几乎不变,用于过滤和分组
pub tags: Vec<String>,
/// 值列:数字,高基数,每次都在变,用于聚合
pub fields: Vec<String>,
}标签(tag)和值(field)必须分开对待,因为它们的使用方式完全不同:
| 标签列 | 值列 | |
|---|---|---|
| 类型 | 字符串(枚举化后是整数) | f64 / i64 |
| 基数 | 低(host 有几百个) | 高(每个点都不同) |
| 用途 | WHERE 过滤、GROUP BY |
sum/avg/max 聚合 |
| 编码 | 字典编码(值 → 序号) | delta / XOR |
| 索引 | 需要(倒排或位图) | 不需要 |
把标签列编码成字典 + 序号,是时序库最划算的一步。 一个只有 500 台主机的集群,host 列编码后每个值只占 9 bit,而不是 "web-01" 那 6 个字节。这在压缩比上是 5 倍以上的差距,而且它让"按标签过滤"变成整数比较。
这就是标签列和值列必须分开的理由:它们的编码方式不同,因为它们的分布不同。 列存的价值就在能对每一列单独选择编码——行存做不到,因为一行里混着两种分布。
第二步:写入路径
WAL:先保证"不丢",再考虑"快"
顺序和讲 WAL 的那篇完全一样,不重复讲,只强调时序场景的调优点:
pub struct Wal {
file: BufWriter<File>,
/// 批量 fsync:攒够这么多条或者超过这么久,才真正落盘一次
pending: usize,
flush_interval: Duration,
last_flush: Instant,
}时序写入的关键权衡是"fsync 频率"。 每条都 fsync,吞吐直接掉到几百 TPS;完全不 fsync,崩溃丢几秒数据。
实际做法是"攒批 + 定时",并且向调用方暴露一个语义:write() 返回成功只代表进了 WAL 缓冲区,flush() 返回成功才是真落盘。 这个区分很重要——回调顺序错了,整个"持久化"承诺就是假的。
WAL 的接口里必须能把"已经持久化"和"已经接受"分开表达。 很多系统的数据丢失都源于这两个状态被合并成一个布尔值。
MemTable:用列式,不要用 HashMap
写入先进 MemTable。MemTable 的格式选择直接影响"能不能查":
pub struct MemTable {
/// 每列一个 Vec,追加式
time: Vec<i64>,
tags: Vec<Vec<u32>>, // 每列一个字典编码后的序号
fields: Vec<Vec<f64>>,
/// 标签字典:值 <-> 序号
dicts: Vec<Dict>,
/// 估算内存占用,到阈值就 flush
mem_bytes: usize,
}
impl MemTable {
pub fn insert(&mut self, point: &DataPoint) -> Result<()> {
self.time.push(point.timestamp);
for (i, tag) in point.tags.iter().enumerate() {
// 字典插入是"写路径上的唯一随机访问"
let id = self.dicts[i].intern(tag);
self.tags[i].push(id);
}
for (i, v) in point.fields.iter().enumerate() {
self.fields[i].push(*v);
}
Ok(())
}
}为什么不用 HashMap<SeriesKey, Vec<Point>>? 因为那样每个 series 是一条独立的链表,聚合时要在几万个链表之间跳——内存访问完全没有局部性。列式 MemTable 让"取第 3 列全部值"变成一次连续扫描。
代价是:列的插入顺序必须一致。 如果两个写入线程并发插不同列,列之间会错位。所以写入必须串行化——这是"列式内存表"隐含的接口约束,很多手写实现栽在这里。
从 MemTable 到 Segment:触发条件
pub fn maybe_flush(mem: &MemTable, cfg: &Config) -> bool {
mem.mem_bytes >= cfg.memtable_size
|| mem.time.last().zip(mem.time.first())
.map(|(l, f)| l - f >= cfg.max_segment_span) // 时间跨度到了
.unwrap_or(false)
}两个条件都要有,因为只看内存会出问题: 一个写入很慢的实例,MemTable 几天也攒不满,查询时却要扫几天全量的内存数据。加上时间跨度上限,保证"最近的数据"总是被切成可用的大小。
第三步:编码必须在写入时做——这是全文最重要的一段
现在到核心了。段一旦落盘就不再修改,所以"用什么编码"这个决定必须在写入时做且必须做对。 查询端没有第二次机会。
时间列:delta-of-delta
时间戳是单调递增的。最朴素的做法是每点 8 字节;差一步是存 delta(相邻差值);再差一步是存 delta 的 delta。
pub fn encode_timestamps(ts: &[i64], out: &mut Vec<u8>) {
// 必须已排序
debug_assert!(ts.windows(2).all(|w| w[0] <= w[1]));
if ts.is_empty() {
return;
}
// 第一个值原样写(8 字节)
out.extend_from_slice(&ts[0].to_be_bytes());
let mut prev_delta: i64 = 0;
let mut first_delta = true;
for i in 1..ts.len() {
let delta = ts[i] - ts[i - 1];
if first_delta {
// 第二个值:写第一个 delta
out.extend_from_slice(&delta.to_be_bytes());
prev_delta = delta;
first_delta = false;
continue;
}
let dod = delta - prev_delta; // delta of delta
prev_delta = delta;
// dod 大部分是 0——因为数据是等间隔采样的
if dod == 0 {
out.push(0); // 1 bit 就够了,这里简化为 1 字节
} else if (-64..=63).contains(&dod) {
out.push(1);
out.push(dod as i8 as u8);
} else if (-512..=511).contains(&dod) {
out.push(2);
out.extend_from_slice(&(dod as i16).to_be_bytes());
} else {
out.push(3);
out.extend_from_slice(&dod.to_be_bytes());
}
}
}它的效果取决于数据是否按固定间隔采样:
| 场景 | 每点耗时(字节) | 说明 |
|---|---|---|
| 原始 i64 | 8 | 基线 |
| 每秒一个点(固定间隔) | ~0.1 | dod 恒为 0 |
| 每 15 秒一个点 | ~0.1 | 同上 |
| 真实监控(有抖动) | 0.5 ~ 2 | 只有部分 dod 为 0 |
10 倍的差距完全来自"规律"本身,而不来自压缩算法。 Gorilla 论文(Facebook 的 TSDB)就是靠这招把内存降了下来——它不是聪明,它是承认了"时序数据是均匀采样的"这个事实,然后把事实写进编码。
编码的本质是"把数据的规律固化成格式"。 规律越强,格式越省。所以选编码之前必须先看数据的分布——这也是为什么列存那篇里字典编码、RLE、增量编码各对应一类数据特征。
值列:XOR 浮点
浮点值不像时间戳那样单调,但相邻两个采样点的值通常很接近。XOR 编码吃的是这个规律:
pub fn encode_floats(values: &[f64], out: &mut Vec<u8>) {
if values.is_empty() {
return;
}
let mut prev_bits = values[0].to_bits();
out.extend_from_slice(&prev_bits.to_be_bytes());
for &v in &values[1..] {
let bits = v.to_bits();
let xor = bits ^ prev_bits;
prev_bits = bits;
if xor == 0 {
// 值完全没变:最常见的情况(比如恒定的内存占用)
out.push(0);
continue;
}
let leading = xor.leading_zeros() as u8; // 前导零
let trailing = xor.trailing_zeros() as u8; // 尾随零
let meaningful = 64 - leading - trailing; // 有效位
// 写 leading / meaningful / 有效位的比特
out.push(1);
out.push(leading);
out.push(meaningful as u8);
// 实际实现应做 bit 级打包;这里用一个 u64 简化为 8 字节
out.extend_from_slice(&xor.to_be_bytes());
}
}真实实现(Gorilla)会把 leading/meaningful/有效位都打进比特流:前一个值的前导零和尾随零数量会"记住",下一个值复用同样的窗口时只要 1 bit。这一层比特打包正是它比朴素 XOR 再省一倍的原因。
注意这个编码有个软肋:一旦值开始剧烈跳动(比如计数器溢出、服务重启后归零),XOR 出来的前导零变少,每点字节数会涨回 8 字节。 生产环境里"重启导致计数器归零"是常见的,所以真实 TSDB 会做分段选择:一段数据如果 XOR 表现差,就换别的编码。
这就是"编码不是压缩算法"的完整含义:它是一种格式决策,必须对数据的局部特征敏感,而且要允许按段回退。 列存那篇讲的"为每一列选编码",在这里升级成了"为每一段的每一列选编码,并且要能验证选得对不对"。
标签列:字典 + 位图
标签列编码成序号之后,"按标签过滤"就变成了对位图的布尔运算:
pub struct TagIndex {
/// 每个标签值对应一个位图:哪些行有这个值
postings: HashMap<(String, String), RoaringBitmap>,
}
impl TagIndex {
pub fn query(&self, filters: &[(String, String, Op)]) -> RoaringBitmap {
let mut result: Option<RoaringBitmap> = None;
for (key, value, op) in filters {
let bm = match op {
Op::Eq => self.postings.get(&(key.clone(), value.clone()))
.cloned().unwrap_or_default(),
// NE / 正则 / 前缀 都从这里展开
Op::Ne => self.all_rows() - self.postings
.get(&(key.clone(), value.clone())).cloned().unwrap_or_default(),
};
// 多个条件之间是 AND:取交集
result = Some(match result {
None => bm,
Some(acc) => acc & bm,
});
}
result.unwrap_or_else(|| self.all_rows())
}
}位图的价值在于"过滤在扫描之前完成"。 先算出"哪些行符合条件"的位图,再按位图去解码对应列——这样解码的量只和结果集成正比,而不是和整段成正比。
时序查询的常见杀手是"高基数标签全表扫"。 有了位图,
WHERE host = 'web-01'只解 1/500 的行;反过来,WHERE status = '200'这种高基数条件如果展开成几百万个位,位图本身反而成了瓶颈。这就是为什么标签索引也有"基数上限"这条线。
第四步:时间分区与段级剪枝
段落盘之后,元数据里必须记下"这个段覆盖了哪段时间",否则查询无从下手:
pub struct SegmentMeta {
pub id: SegmentId,
/// 这个段的悬挂小文件名(编码后的列文件)
pub files: SegmentFiles,
/// 覆盖的时间范围 —— 时间剪枝的依据
pub min_time: i64,
pub max_time: i64,
/// 行数,用于优化器估算代价
pub rows: u64,
/// 每个标签的取值集合 —— 标签剪枝的依据
pub tag_stats: Vec<TagStat>,
}
pub struct TagStat {
pub key: String,
/// 这个段里该标签出现过的所有值(基数低时才存)
pub values: Option<RoaringBitmap>,
pub min: Option<i64>,
pub max: Option<i64>,
}查询规划的第一步是"把所有段过一遍,扔掉不可能的":
pub fn plan_segments(
segments: &[SegmentMeta],
time_range: (i64, i64),
filters: &[(String, String, Op)],
) -> Vec<SegmentId> {
segments
.iter()
.filter(|seg| {
// ① 时间范围不相交,直接丢
!(seg.max_time < time_range.0 || seg.min_time > time_range.1)
})
.filter(|seg| {
// ② 如果某个过滤条件在该段的取值集合里根本不存在,整个段丢掉
// 这一步的成本是"读几个位图",收益是"省掉解压一个几 MB 的段"
filters.iter().all(|(k, v, op)| {
match op {
Op::Eq => seg.tag_stats.iter()
.find(|s| &s.key == k)
.map(|s| s.values.as_ref().map(|bm| !bm.is_empty()).unwrap_or(true))
.unwrap_or(true), // 没这个标签,不做判断
_ => true,
}
})
})
.map(|s| s.id)
.collect()
}这两个剪枝是整篇里性价比最高的代码。
| 场景 | 不剪枝 | 剪枝后 |
|---|---|---|
| 查最近 1 小时(数据保留 30 天) | 扫 720 个段 | 扫 1 ~ 2 个段 |
| 查某台主机(500 台中的 1 台) | 解压全部行 | 只解 1/500 的行 |
注意两级的成本模型完全不同: 时间剪枝看的是元数据里的两个整数,成本几乎是零;标签剪枝要读位图,成本略高但远低于解压。所以顺序必须是"先时间、后标签",反过来会白白多读一堆位图。
剪枝的本质是"用元数据换 IO"。 元数据是写的时候顺手记的(min/max、位图),查询时用它排除整块数据。元数据不加,查询就只能全扫——这也解释了为什么"写的时候多记一点",最后总是划算的。
Compaction:小段合并
MemTable 每次 flush 都产出一个段。写入快的时候几秒一个段,一天下来几万个。查询规划要在几万个段上跑 filter,规划本身就成了瓶颈。
pub fn pick_compaction(segments: &[SegmentMeta], cfg: &Config) -> Option<Vec<SegmentId>> {
// 按时间排序,找出连续的小段
let mut sorted: Vec<_> = segments.iter().collect();
sorted.sort_by_key(|s| s.min_time);
let mut run = Vec::new();
for seg in sorted {
if seg.rows < cfg.small_segment_rows {
run.push(seg.id);
if run.len() >= cfg.compaction_fan_in {
return Some(run);
}
} else {
run.clear();
}
}
None
}合并的时候有个优化不能忘:合并后的段要重新计算编码决策。
因为小段的数据往往形状不同(有的段是平稳期,有的是抖动期),合到一起之后统一再选一次编码,通常比"把各自的编码块拼起来"更省。 代价是必须把两边都解码——这就是"写时编码"的隐含成本:任何重组都要付一次全量解码。
这也是为什么时序库宁可被"读时合并"(查询时逻辑上把多个段当一个),也不愿意频繁物理合并。 合并的收益是"元数据变少、剪枝变准",成本是"全量解码 + 重编码"。这个账必须按段数来算,而不是按数据量来算。
第五步:查询路径
有了段和时间剪枝,查询实际上是"三段式":
pub fn query(
catalog: &Catalog,
time_range: (i64, i64),
filters: Vec<(String, String, Op)>,
aggs: Vec<AggSpec>,
step: Option<Duration>, // 如果指定了 step,就是降采样查询
) -> Result<QueryResult> {
// ① 规划:选出要读的段
let seg_ids = plan_segments(&catalog.segments, time_range, &filters);
// ② 每个段:按位图解码 → 向量化聚合
let mut acc = AggAccumulator::new(&aggs);
for id in seg_ids {
let seg = catalog.open_segment(id)?;
// 标签过滤在位图上算完,再映射到行的位置
let row_bitmap = seg.tag_index.query(&filters);
// 时间范围也要在段内再裁一次(段级剪枝是粗的,段内再精确一次)
let (start, end) = seg.row_range_for(time_range);
// 只解需要的列:聚合用到哪些值列,才解哪些
let needed: Vec<&str> = aggs.iter().filter_map(|a| a.field()).collect();
let columns = seg.decode_columns(&needed, start, end)?;
// 向量化:一批一批地累加(向量化执行那套接口原封不动搬过来)
acc.update_bitmap(&columns, &row_bitmap, start, end)?;
}
acc.finish()
}三个细节决定了它快不快:
第一,列裁剪是自动的。 aggs 里只提到 cpu_usage,那就只解 cpu_usage 这一列。如果表有 50 个字段,这一步直接省掉 49/50 的解码量。这正是内存 SQL 引擎那篇里那个 collect_required_columns 在时序场景的翻版,但这里更彻底——因为时序查询几乎从不 SELECT *。
第二,位图让聚合"跳过"不符合条件的行。 如果过滤后的位图很稀疏,向量化循环里会出现大量"跳过"。这时有个反直觉的优化:不回退到逐行,而是把位图转成有序的行号列表,再用"批量 + 偏移"的方式喂给向量化内核。 保持批量的形状,编译器才愿意优化。
第三,时间范围的裁剪必须做两遍。 段级是"整个段和查询范围有没有交集",段内是"哪些行的时刻落在范围内"。只做第一遍会多解一段数据;只做第二遍会把段全开一遍。两遍都不做就是全量扫描。
向量化聚合器
聚合器本身简单,但有一个容易写错的地方:
pub struct AvgAccumulator {
sum: f64,
count: u64,
}
impl AvgAccumulator {
pub fn update(&mut self, col: &Column, bitmap: &RowBitmap, start: usize, end: usize) {
match col {
Column::F64(vals) => {
// 逐行累加会被编译器自动向量化,但只在"没有条件分支"时
// 所以这里用 bitmap 的批量迭代器,而不是 while 里 if
for idx in bitmap.iter_set_bits_in(start..end) {
self.sum += vals[idx];
self.count += 1;
}
}
_ => unreachable!("avg 只处理数值列"),
}
}
pub fn finish(&self) -> f64 {
// 空集合返回 NaN 而不是 0:0 是一个合法的平均值,NaN 不是
if self.count == 0 { f64::NAN } else { self.sum / self.count as f64 }
}
}最后那个 NaN 的选择不是小事。 监控图上"没有数据"和"平均值是 0"是两回事——如果返回 0,告警系统会以为"CPU 使用率正常",而实际上是指标根本没上报。 这类语义错误在时序系统里比性能问题更容易酿成事故。
聚合的"空集语义"必须在实现的最底层就定下来。 一旦把
NaN换成0,它会顺着计算链一路传下去,等你发现的时候已经发过好几次误告警了。
第六步:降采样——把"查询时聚合"变成"写入时预聚合"
到这里系统能跑了。但有个规模问题躲不过:
原始数据:1 秒 1 个点 × 30 天 = 2,592,000 个点/序列
查询:过去 30 天的 cpu 使用率趋势图,图表宽度只有 800 像素查询要 260 万个点,屏幕上只能显示 800 个。 就算向量化再快,这也是纯浪费——而且这才是时序库真正的性能瓶颈所在,不是单点计算慢,是"算了 3000 倍的冗余"。
解法是预聚合(rollup / downsampling):
pub struct RollupRule {
pub source: String, // 原始表
pub target: String, // 预聚合表
pub interval: Duration, // 聚合粒度,比如 1 分钟
pub aggs: Vec<AggSpec>, // 存 min/max/sum/count,而不是 avg
pub retention: Duration,
}注意 aggs 里存的是 sum 和 count,而不是 avg——这是全文里最容易被写错的一个设计决策:
| 存的东西 | 能否再合并? | 说明 |
|---|---|---|
avg |
不能 | 两个 5 分钟平均值的平均 ≠ 10 分钟平均值 |
sum + count |
能 | 相加即可,sum/count 得到正确平均 |
min / max |
能 | 取 min / max 即可 |
p99 |
不能 | 分位数不可合并,只能存近似草图(HDR / t-digest) |
// 正确:可合并的聚合器
pub struct MergeableAvg { sum: f64, count: u64 }
impl MergeableAvg {
/// 两个 5 分钟桶合并成 10 分钟桶
pub fn merge(a: &Self, b: &Self) -> Self {
Self { sum: a.sum + b.sum, count: a.count + b.count }
}
}这就是"聚合必须可合并(algebraic / decomposable)"这条铁律。 只要聚合器满足可合并,任意粒度的 rollup 都能继续往上卷(1 分钟 → 5 分钟 → 1 小时 → 1 天),而不会引入误差。
反过来,不可合并的聚合(avg、分位数)一旦预聚合,就永久损失了精度。 所以真实系统里 avg 是"查询时用 sum/count 算出来的",而不是存下来的——表面上是个 SQL 语义细节,实际上是"预聚合能不能做"的前提条件。
预聚合的选择标准不是"省不省空间",而是"能不能再合并"。 这个标准决定了你看的到底是"每月汇总报表"还是"一份永远不能再被重算的错误数据"。
乱序写入与迟到数据
前面所有设计都默认"时间戳递增"。真实环境会有例外:
- 采集端时钟不同步,十几秒的抖动很常见
- 网络重传导致后到的点时间戳更早
- 批量导入历史数据
处理方式分三档,成本依次上升:
第一档:容忍小窗口内的乱序。 MemTable 允许写入时间戳比当前最大时间小一点(比如 5 分钟),落盘时对时间列做一次稳定的索引排序。
impl MemTable {
pub fn insert(&mut self, p: &DataPoint) -> Result<()> {
let latest = self.time.last().copied().unwrap_or(i64::MIN);
if p.timestamp < latest - self.late_window {
// 超出容忍窗口:不能塞进当前的 MemTable
// 因为段的"时间有序"这个前提会被破坏
return Err(Error::TooLate);
}
// ... 正常追加
Ok(())
}
}这里的关键不是"能不能存",而是"存了之后段还时间有序吗"。 段内有序是所有剪枝和 delta 编码的前提,丢掉它,delta-of-delta 直接失效,时间剪枝也只能退化成全段扫描。
第二档:单独放一个"迟到段"。 超出窗口的点写进一个专门的小段,查询时把它当独立数据源一起读。
第三档:拒绝。 超过保留期的写入直接报错。
这三档没有哪一档是"对"的,但必须显式选一档。 最常见的错误是"默默允许任意乱序",结果段内顺序全乱,剪枝失效,性能悄悄掉到全表扫——而且因为功能上还"正确",监控上完全看不出来。
"正确性上没问题的降级"是最危险的一类 bug。 乱序写入不会让查询出错,只会让它变慢——所以必须有办法观测到"段内有序性被破坏了多少"这个指标。
保留策略:删除也是分层的
30 天前的数据要删。但"删"在时序库里不是一行 DELETE,而是三个层次的动作:
| 层次 | 动作 | 频率 |
|---|---|---|
| 段 | 整段过期 → 直接删文件 | 每天 |
| 行 | 段内部分行过期 → 重写段 | compaction 时顺带做 |
| 值 | 只保留聚合(rollup),原始点删掉 | 按 retention 分级 |
最有价值的是第一层:整段删除。
因为段是不可变的,"删掉整个段"就是一次 unlink——不需要回收空间、不需要重写索引、不影响其他段的查询。 所以工程上的做法是对齐段边界和保留期:段就是按天切的,那"保留 30 天"就精确地等于"删掉 30 个整段"。
pub fn apply_retention(catalog: &mut Catalog, now: i64, keep: Duration) -> Result<usize> {
let cutoff = now - keep.as_secs() as i64;
let expired: Vec<_> = catalog.segments.iter()
// 只有 max_time 都过期了,才能整段删
.filter(|s| s.max_time < cutoff)
.map(|s| s.id)
.collect();
for id in &expired {
catalog.remove_segment(*id)?; // 元数据里摘掉,再删文件
}
Ok(expired.len())
}代价是"跨边界的段"必须重写。 如果一个段跨了保留期边界(比如从 23:00 到次日 02:00),它只能等下一个边界,或者被 compaction 切开。所以段的切分粒度 = 保留期的最小精度,这两个参数在设计时必须一起定。
"不可变 + 整块删除"是时序库最重要的工程红利。 它把"删数据"这个在 OLTP 里最贵的操作,变成了一个文件系统的原子操作。这也是为什么时序库敢承诺"每天几亿个点、保留 90 天",而同样的量放在关系型数据库里,光 vacuum 就能把 IO 打满。
结论
把散落的轮子拼成一个数据库之后,能看清这个系统真正的形状:
写入路径 查询路径
──────── ────────
WAL ← 只承诺"不丢" 规划 ← 元数据剪枝(时间 + 标签)
↓ ↓
MemTable ← 列式,才能被直接查 位图 ← 过滤在解码之前
↓ ↓
Segment ← 编码在这里定,之后不能再改 解码 ← 只解需要的列
↓ ↓
Compaction ← 重编码的代价 = 全量解码 聚合 ← 批量 + 可合并的聚合器四件事里,有三件在列存、向量化执行、WAL 那三篇里已经讲过。真正新的、也是这篇的重点,是两处"接口":
第一处:段的格式是写入和查询之间的契约。 编码一旦选定就不能改,所以"怎么编码"这个决定的正确性完全由"写入时的数据形状"决定。这也意味着段格式的版本兼容是硬约束——新版本写的段,老版本读不了就是读不了,没有折中。
第二处:聚合器必须可合并。 这一条决定了这个数据库能不能提供降采样,而降采样决定了它能不能处理"30 天趋势图"这种真实的查询。avg 存不存得下来,看起来是个小事,实际上决定了整个系统的能力边界。
和前面轮子的对照
| 用到的轮子 | 在这篇里的角色 | 变了吗 |
|---|---|---|
| WAL | 写入的第一道保证 | 没变,但接口多了"已接受 vs 已持久化"的区分 |
| 列存与编码 | 段的格式 | 升级了:从"一列一种编码"变成"一段一列一种编码" |
| 向量化执行 | 段内聚合 | 没变,但输入从整段变成"位图筛过的稀疏行" |
| 布隆 / 位图 | 标签过滤 | 从"近似判断存在性"变成"精确筛选行号" |
| 对象池 | 解码缓冲复用 | 没变,是唯一"直接抄过来"的部件 |
这张表里能看出一个规律:能直接抄的部件最少,大多数轮子在换一个场景之后都"变了"。 变的地方就是系统设计真正的工作量所在——讲协程调度的那篇、讲 TinyLFU 的那篇,在这篇里根本用不上,因为时序库的并发模型简单得没有调度问题。
所以"组装"不是把零件拼起来,而是找出哪些零件在这个场景里必须重新定义接口。 下一篇换一个完全不同的场景(向量检索服务),会看到同一批轮子被要求给出完全不一样的接口。