返回文章列表

用 Rust 从零搭一个时序数据库:编码不是存储层的事,是写入时的决定

1042 字·8 分钟阅读
Rust从零造轮子时序数据库

前面分别写过列存与编码、向量化执行、WAL。但它们各自只解决了一段路:一篇讲"列怎么编码",一篇讲"批怎么算",一篇讲"日志什么时候 fsync"。

真正的问题是这三段怎么拼成一个数据库——能持续写入、能按时间范围查、能在重启后不丢数据。这篇把内存 SQL 引擎那套思路换一个场景重做一遍。

时序数据的形状,决定了整个架构

先把数据的形状说清楚,架构基本就是它的直接推论:

特征 数值
写入量 每秒几十万到几百万个点
查询量 每秒几个到几十个
更新/删除 几乎没有
写入顺序 基本按时间递增
查询形状 时间范围 + 标签过滤 + 聚合(avg/max/rate)
点的大小 时间戳 8 字节 + 值 8 字节,通常只有几十字节

这张表里有三条硬约束:

  1. 写远多于读(典型是 1000:1)。所以写入路径上不能做重活——任何"每次写入都要重新组织数据"的设计都会死。
  2. 数据永远按时间追加。这使得"分段 + 段内有序"成为可能,而且不需要考虑原地更新。
  3. 查询从来不要原始点,只要聚合结果。所以"要不要预聚合"是一个可以主动做的决定,而不是只能被动响应。

整体架构:两条路径,一份数据

写入路径                                   查询路径
────────                                   ────────
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        1028
pub 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 的那篇,在这篇里根本用不上,因为时序库的并发模型简单得没有调度问题。

所以"组装"不是把零件拼起来,而是找出哪些零件在这个场景里必须重新定义接口。 下一篇换一个完全不同的场景(向量检索服务),会看到同一批轮子被要求给出完全不一样的接口。