突破单机极限:TiDB 全局索引与 ES 位图检索,各自解决了什么,又把什么留给了你

TiDBElasticsearch分布式数据库存储架构工程化

突破单机极限:TiDB 全局索引与 ES 位图检索,各自解决了什么,又把什么留给了你

TL;DR 前三篇的结论是:20 人用的内部台账,单机 MySQL 加宽覆盖索引就够了;大报文放分布式 KV;Key-List 只适合带主 ID 的长列表。这篇回答最后一个问题:如果有一天单机真的不够了,该换成什么,换完之后哪些问题消失了,哪些还在。

先说清楚一个前提:我们这个台账目前没有上 TiDB,也没有上 ES。所以本篇没有实测数字,所有判断都来自机制推导和官方文档,文中会标明哪些是需要你自己压测确认的。

结论先放这里:

  • TiDB 解决的是「容量」和「没有分表键」:二级索引自己就是一组按值有序的 Region,不带分表键也能精准定位。但它把单机的索引全扫变成了多机并行全扫,总工作量没变,深分页和 COUNT 的问题原样保留;
  • ES 解决的是「多条件自由组合」:每个字段独立建索引,不存在最左前缀,条件结果还能按段缓存。但它有 10000 条的翻页上限,精确总数依然要逐条数,而且多了一条要对账的同步链路;
  • 两者都不能替你做的决定是:产品上要不要精确总数、要不要任意跳页。

📚 《千万级业务存储架构与实战》系列


📌 本文要点

  • 单机 MySQL 会撞上的墙有两堵,方向不同:一堵是容量(索引装不进内存、DDL 跑不动),一堵是算力(无锚点多条件查询在高并发下把 CPU 扫满)。前者指向 TiDB,后者指向 ES,搞混了会换错。
  • TiDB 里一个二级索引就是一段按「索引列值 + 主键」编码的有序 KV,被切成若干 Region 分布在多台机器上。第 2 篇设计的宽覆盖索引可以原样搬过去,而且依然有效。
  • Coprocessor 下推让过滤和 COUNT 在每个 TiKV 上并行执行,耗时大致按节点数缩短,但 CPU 总消耗不变。高并发下它是用机器数换时间,不是让扫描消失。
  • ES 的多条件查询不是「一条联合索引从左往右匹配」,而是每个条件各自产出一个文档集合,再按代价从小到大做交集。T-1 只读的数据让这些集合可以一整天复用缓存。
  • ES 的 track_total_hits 默认只精确数到 10000,超过就返回「10000+」。这恰好就是第 1 篇建议的产品方案——砍掉精确总数,ES 只是把它做成了默认行为。

一、先分清是哪堵墙

第 2 篇最后剩下的问题是 COUNT,第 1 篇最后算的是 CPU 时间片账。把单机 MySQL 可能撞上的问题列全,其实是两类:

现象根因属于哪堵墙
覆盖索引超出 Buffer Pool,全扫开始读磁盘数据量增长容量
给大表加一个索引要跑几个小时数据量增长容量
单表到了几千万、上亿行,备份恢复以小时计数据量增长容量
无锚点多条件查询,每秒几十次就把 CPU 打满每次查询都要线性扫描算力
精确 COUNT 随命中行数线性变慢每次都要逐条数算力
中间页码的取数随 offset 线性变慢每次都要跳过前面的行算力

两类问题的解法完全不同:

  • 容量问题,本质是「一台机器装不下」,要的是把数据和索引水平切开、还能不带分表键查询。这是 TiDB 的主场。
  • 算力问题,本质是「每次查询做了太多重复的线性工作」,要的是换一种不需要线性扫描、或者能复用上次结果的查询算法。这是 ES 的主场。

如果只是 COUNT 慢,第 2 篇第七节已经给了更便宜的答案:用「查询条件 + 同步批次号」缓存它。在换存储之前,先确认自己撞的是哪堵墙。


二、TiDB:没有分表键,为什么还能精准定位

1. 表在 TiKV 里长什么样

TiKV 没有「表文件」,只有一个按 Key 全局有序的 KV 空间,按大小切成一个个 Region(默认 96MiB,新版本有调大的趋势,以所用版本文档为准),每个 Region 三副本,通过 Raft 同步。

一张表会被编码成三类 KV:

数据KeyValue
行数据t{表ID}_r{主键}整行的列值
非唯一索引t{表ID}_i{索引ID}{索引列值}{主键}空
唯一索引t{表ID}_i{索引ID}{索引列值}主键

(主键是聚簇索引时用主键值本身,否则用隐藏的 _tidb_rowid。)

关键在第二行:一个二级索引的所有条目,Key 前缀相同,后面跟着索引列值,所以它们在全局有序空间里是连续的一段,并且按索引列值排好序。这段数据有多大,就被切成多少个 Region,和行数据的 Region 完全独立。

这就是「没有分表键也能精准定位」的原因。传统分库分表是按分表键把整行切开,不带分表键就不知道去哪张表;TiDB 是每个索引各自按自己的列值切开,查询带了哪个索引的前缀,就直接定位到那个索引的那几个 Region。

2. 第 2 篇的宽覆盖索引搬过来还有效吗

有效,而且道理完全一样。

CREATE INDEX idx_lend_time_cover ON t_loan_iou (
  lend_time, id,
  loan_status, customer_type, loan_period_cnt,
  annual_rate, loan_amt, residue_prin, fund_name
);

在 TiKV 里,这个索引的 Key 是 t{表ID}_i{索引ID}{lend_time}{id}{loan_status}…{主键},天然按 (lend_time, id) 有序。第 2 篇里那几条规律都成立:

  • 查询只需要索引里的列时,TiDB 的执行计划是 IndexReader,不回表,对应 MySQL 的 Using index;
  • 需要回表时是 IndexLookUp:先从索引 Region 里批量拿主键,再按主键批量去行数据 Region 取整行。这一步本身就是批量、并发的,有点像第 3 篇的「轻索引 + mGet 回表」,只是由数据库替你做了;
  • 延迟关联的写法在 TiDB 里同样能把回表压到只有 10 行。

3. Coprocessor 下推:把全扫并行化,而不是消灭它

用户不填时间条件、只填余额和定价区间时,在 MySQL 里是一次索引全扫(type = index)。在 TiDB 里会发生什么?

TiDB 会把这个索引涉及的所有 Region 拆成一批 Coprocessor 任务,发给各个 TiKV。每个 TiKV 在本地扫自己负责的那几个 Region,在本地做过滤(Selection),只把满足条件的结果送回 TiDB。COUNT 也一样:每个 TiKV 先算出自己那部分的数量,TiDB 再把各部分加起来。

EXPLAIN SELECT COUNT(*) FROM t_loan_iou
WHERE residue_prin BETWEEN 100 AND 60000
  AND annual_rate  BETWEEN 10 AND 50;

执行计划里应该看到:IndexFullScan 和 Selection 都标在 cop[tikv] 上,StreamAgg 或 HashAgg 拆成两层,下层在 cop[tikv]、上层在 root。

这里要算清楚账:

  • 耗时:扫描被摊到了 N 个 TiKV 上,墙钟时间大致按节点数缩短;但实际加速比通常明显低于节点数——它同时受最慢的那个 Region(长尾)、TiDB 层的归并、以及网络与编解码开销限制;
  • 总工作量:每一个索引项依然要被读一次、比较一次,CPU 总消耗和单机全扫是同一个量级,还要加上网络和编解码的开销。

所以 TiDB 对第 1 篇那笔 CPU 时间片账的回答是:不变,但你可以加机器。每秒 500 次 90ms 的扫描需要 45 秒 CPU,单机 16 核扛不住,TiDB 可以拿 4 台、8 台 TiKV 去分担。这是线性的成本扩展,不是算法上的改进。

4. TiDB 没有解决的三件事

  1. 深分页。ORDER BY lend_time DESC, id DESC LIMIT 85040, 10 下推时,Limit 会变成 offset + limit,依然要沿着索引顺序读过前 85050 条。第 2 篇的尾页反转在 TiDB 里同样需要,同样只能把最坏情况减半。另外 RocksDB 的反向 seek 通常比正向略慢,而台账默认就是倒序,这一项要单独压测确认。
  2. 精确 COUNT 的总量。如上所述,它被并行化了,没被消灭。真想让 COUNT 和聚合变便宜,TiDB 生态里的答案是 TiFlash:给表加一个列存副本(ALTER TABLE t_loan_iou SET TIFLASH REPLICA 1),统计类查询只读需要的两三列,由优化器决定走行存还是列存。这本质上是第 1 篇第五节说的列存,只是 TiDB 帮你做了同步。
  3. 点查延迟。事务要从 PD 取时间戳,读写要经过网络和 Raft 多副本,简单点查通常在毫秒级(常见 2~10ms),比同机房单机 MySQL 高。

5. 迁过去要提前算的写入账

我们的数据是夜里 T-1 批量写入,这个特征在 TiDB 上会带来两个具体的热点问题:

  • 自增主键热点:连续自增的 id 意味着所有新行都写到行数据的最后一个 Region。解法是主键改用 AUTO_RANDOM。排序里的 id 只是用来打破同一时刻的平局,要求唯一、不要求递增,换成随机值不影响分页的正确性。
  • 时间索引热点:这一点更容易被忽略。夜里写入的全是昨天放款的借据,lend_time 全部挤在同一个值域,宽覆盖索引的写入会集中到索引最尾部的那一两个 Region。可以在同步前按时间范围预切分:
SPLIT TABLE t_loan_iou INDEX idx_lend_time_cover
  BETWEEN ("2026-11-17 00:00:00") AND ("2026-11-18 00:00:00") REGIONS 16;

还有两件和 MySQL 习惯不同的事:

  • 单个事务有大小上限,夜里同步不能一条事务写完几百万行,要分批提交;大批量初始化导入用官方的导入工具(IMPORT INTO 或 TiDB Lightning),不要逐行 INSERT。
  • 借据余额每天都在变,T-1 的变更不只是新增行,还有大量存量行的更新。TiKV 是 MVCC 多版本,更新会留下旧版本,在 GC 清理之前,扫描要跳过这些旧版本。大批量更新之后的那段时间,扫描类查询会变慢,压测时要把这个时间段也覆盖到。

兼容性方面,TiDB 兼容 MySQL 协议,但不支持存储过程、触发器,AUTO_INCREMENT 只保证唯一、不保证连续。这些在迁移前都要扫一遍现有代码。


三、Elasticsearch:多条件检索换了一种算法

1. 同一条查询在 ES 里长什么样

第 2 篇那条「借据余额 100~60000、年化定价 10%~50%,按放款时间倒序」的查询,在 ES 里是:

{
  "size": 10,
  "track_total_hits": 10000,
  "query": {
    "bool": {
      "filter": [
        { "range": { "residue_prin": { "gte": 100, "lte": 60000 } } },
        { "range": { "annual_rate":  { "gte": 10,  "lte": 50 } } }
      ]
    }
  },
  "sort": [
    { "lend_time": "desc" },
    { "id": "desc" }
  ]
}

条件全部放在 filter 里而不是 must 里:台账筛选只关心命中与否,不需要相关性打分,filter 不算分,而且只有 filter 上下文的结果才有资格进缓存。

2. 每个字段各自建索引,所以没有最左前缀

ES(底层是 Lucene)不建联合索引,而是给每个字段建自己的结构:

字段类型用途底层结构
keyword(状态、资方、单号)精确匹配倒排索引:每个值对应一个文档 ID 列表
数值、日期(余额、定价、时间)范围查询BKD 树:多维空间切分,按范围快速圈出文档
数值、日期、keyword排序、聚合doc_values:按文档 ID 顺序存放的列式数据

这就是 ES 没有最左前缀问题的原因:MySQL 的联合索引是一棵按 (a, b, c) 排好的树,跳过 a 就没法定位;ES 里 a、b、c 是三个互不相干的结构,查询带了哪几个就用哪几个。

代价也随之而来:MySQL 一个联合索引同时解决「过滤」和「排序」,ES 里过滤用倒排和 BKD,排序要另外读 doc_values,两件事是分开做的。

3. 多条件怎么求交:比「按位与」多一层

第 1 篇用「64 位按位与」来描述 ES 的多条件求交,那是一个直观模型。Lucene 实际的执行要再精确一点:

  1. 每个条件先变成一个能按文档 ID 递增遍历的迭代器,并估算自己大概命中多少条;
  2. 求交时,按估算命中数从小到大排,由最小的那个领头,其余的只做「跳到不小于某个文档 ID 的位置」(advance),而不是全量遍历。命中 100 条的条件领头,命中 500 万条的条件只会被跳查 100 次左右;
  3. 对数值范围条件,ES 还会根据它在交集里的角色自动选择执行方式:领头时用 BKD 圈出文档集合,作为被跳查的一方时改用 doc_values 逐个校验,避免为了一个宽范围先把几百万个文档 ID 全部圈出来。

位图出现在缓存这一层:一个 filter 条件在同一个段(segment)上被反复执行之后,Lucene 会把它的结果存成文档 ID 集合(稠密时是定长位图 FixedBitSet,稀疏时是 RoaringDocIdSet),下次直接复用,省掉的正是从 BKD 圈出文档集合的那一步。这个缓存有几个容易误解的规则:

  • 它按段缓存,段不变,缓存就一直有效;
  • 不是第一次执行就缓存,而是在最近的查询里重复出现过几次才缓存;
  • 太小的段不缓存,本身就足够快的查询(比如单个 term)也不缓存;
  • 默认占堆内存的 10%,按 LRU 淘汰。

4. 为什么 T-1 只读几乎是为 ES 量身定做

ES 在实时业务里的几个老毛病——写入后约 1 秒才可见、频繁更新导致段碎片和缓存失效——都来自「数据在变」。我们的数据一天只变一次,可以把 ES 用成一个每晚重建的只读索引:

  1. 每晚建一个新索引,建索引期间关掉刷新、不要副本,用 bulk 全量写入:
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 0,
    "refresh_interval": "-1",
    "index.sort.field": ["lend_time", "id"],
    "index.sort.order": ["desc", "desc"]
  },
  "mappings": {
    "dynamic": "strict",
    "properties": {
      "id":              { "type": "long" },
      "iou_id":          { "type": "keyword" },
      "user_id":         { "type": "long" },
      "lend_time":       { "type": "date" },
      "loan_status":     { "type": "keyword" },
      "customer_type":   { "type": "keyword" },
      "fund_name":       { "type": "keyword" },
      "loan_period_cnt": { "type": "integer" },
      "annual_rate":     { "type": "scaled_float", "scaling_factor": 10000 },
      "loan_amt":        { "type": "scaled_float", "scaling_factor": 100 },
      "residue_prin":    { "type": "scaled_float", "scaling_factor": 100 }
    }
  }
}
  1. 写完后刷新一次、合并成少量段(_forcemerge)、打开副本、设置为禁止写入;
  2. 用别名原子切换,查询方始终只访问别名:
{
  "actions": [
    { "remove": { "index": "loan_iou_20261117", "alias": "loan_iou_read" } },
    { "add":    { "index": "loan_iou_20261118", "alias": "loan_iou_read" } }
  ]
}

这套做法有几个直接的好处:

  • 段一整天不变,上一节说的条件缓存一整天有效;
  • 每晚全量重建,ES 和 MySQL 不会慢慢漂移出差异,对账只需要比较当晚的行数和抽样;
  • 切换是原子的,白天任何时刻看到的都是同一批数据,第 2 篇说的「COUNT 和取数之间数据会变」的问题不存在;
  • 出了问题,把别名切回前一天的索引就是回滚。

几个设置的取舍要说明一下:

  • 只用 1 个主分片:千万行、每行几百字节,索引体积是几 GB 量级,一个分片足够。分片多了,每次查询要在多个分片上各取一遍再归并,分页反而更贵;
  • 不是用来做范围查询的枚举字段(客户类型、资方)映射成 keyword,精确匹配走倒排,比数值类型的范围结构更合适;
  • 金额用 scaled_float 只是为了检索。ES 里的数据是给列表用的副本,金额的权威值依然在 MySQL,详情页和导出以 MySQL 为准;
  • index.sort 让段内文档按 (lend_time, id) 倒序物理排列,作用和第 2 篇把 id 放在索引第 2 列一样,见下一节。

全量重建的前提是重建时间放得进夜间窗口。千万行的借据表问题不大;6000 万行的授信表要实测,放不进去就改成按月分索引、只重建有变化的月份,或者改成按 id 增量覆盖写,代价是对账要做得更细。

5. 分页和总数:ES 的默认值就是产品方案

ES 在分页和总数上有三条默认规则,正好对应第 1 篇第四节说的「产品交互做减法」:

  • 翻页上限:from + size 默认不能超过 10000(index.max_result_window)。这是一个故意设置的护栏,因为 from 在 ES 里和 MySQL 的 offset 一样,要先取出前 from + size 条再丢掉前面的;
  • 总数上限:track_total_hits 默认只精确数到 10000,超过就返回「至少 10000 条」。想要精确值要显式设为 true,代价是把所有命中都数一遍;
  • 深翻页的正确方式:用 search_after 带上一页最后一条的排序值 [lend_time, id] 往后取,配合 point in time 固定视图。这和第 2 篇导出用的游标分页是同一个思路。

再加上上一节设置的 index.sort:当查询的排序和索引排序一致、并且不要求精确总数时,Lucene 在每个段里凑够需要的条数就可以提前停止,不用把所有命中都过一遍。这和第 2 篇里「叶子节点顺序等于排序要求,凑够 offset + 10 条就停」是同一个原理,换了一种存储重新实现了一遍。

如果产品依然要求精确总数和跳尾页,在 ES 上也能做,但要知道边界在哪:

  • 精确总数:单独发一个 size: 0、track_total_hits: true 的请求。ES 的分片请求缓存默认会缓存 size: 0 的结果,索引不刷新就一直有效。在每晚重建的只读索引上,这就是第 2 篇第七节「按条件 + 批次号缓存 COUNT」的内置版本,不用自己写;
  • 尾页:尾页反转在 ES 上同样适用,把排序改成正序、from 换算成从另一头数的位置。但要注意,反转后排序方向与 index.sort 相反,会失去上一节说的段内提前终止能力,退化成完整的 from + size 扫描——功能仍然成立,只是成本和第 2 篇「从另一头数几条就停」已经不是一回事;
  • 中间页:前后两头各能翻 10000 条,每页 10 条就是前 1000 页和后 1000 页。正中间的页码在 ES 上是翻不到的,这一点必须和产品提前对齐。

6. ES 没有解决的事

  1. 精确 COUNT 依然要逐条数。有了缓存,每一条的成本低了,但工作量依然和命中行数成正比;
  2. 中间深页码依然不行,而且比 MySQL 多了一条硬上限;
  3. 多了一条同步链路。MySQL 依然是权威数据源(还款计划、配置、审计都在里面),ES 是它的派生副本,同步、重建、对账、告警,一样都不能少;
  4. 内存成本。ES 的堆内存一般不超过 31GB 左右,机器剩下的内存要留给操作系统页缓存,倒排、BKD 和 doc_values 的读取都依赖它。同等数据量下,机器成本明显高于单机 MySQL;
  5. 它不是主库。没有跨文档事务,不能作为台账数据的唯一存储。

四、同一组问题,三个答案

问题单机 MySQL(第 2 篇方案)TiDBES(每晚重建只读索引)
单表容量几千万行以内,索引要装得进内存水平扩展到数亿行体积由副本决定,千万行几 GB
不带分表键的查询能查,单机内无所谓分表键能查,每个索引独立分片能查,每个字段独立建索引
多条件自由组合依赖一个宽覆盖索引,跳过前导列就全扫同 MySQL,但全扫被并行化每个条件独立,按代价求交,结果可缓存
中间深页码随 offset 线性变慢同 MySQL前后各 10000 条以外翻不到
精确 COUNT随命中行数线性变慢并行化;或用 TiFlash 列存默认只数到 10000;精确值可缓存
高并发多条件CPU 很快打满加机器线性扩展缓存命中后单次很便宜
点查延迟亚毫秒到 1ms常见 2~10ms毫秒级,不适合当主库点查
额外成本无集群运维、写热点治理同步链路、对账、内存

读这张表的方式是:先找出自己真正的瓶颈在哪一行,再看哪一列在那一行上有实质改善。如果改善只是「并行化」或者「加机器」,要算一下机器成本和直接改产品交互比哪个便宜。


五、回到我们的台账:什么时候会换,换成什么

现在不换:20 个人用,峰值 1~2 QPS,查询有必填锚点和时间范围上限,最贵的 COUNT 是 90ms。这个阶段引入任何一个分布式组件,都是用确定的运维成本去换一个还不存在的问题。

能预见的两种变化,对应两个不同的方向:

  1. 数据量涨上去,但用的人还是这么多。比如授信表从 6000 万涨到几亿行,覆盖索引装不进内存。先做的是第 1 篇说的按时间分区和冷数据归档,因为用户绝大多数时候只看近两年;归档之后热数据依然放不下,再迁 TiDB,并按本文第二节第 5 小节提前处理写热点。
  2. 用的人多起来,比如台账开放给几百个客服日常使用,无锚点多条件查询到了每秒几十次。这时 MySQL 的瓶颈是 CPU 扫描,TiDB 只能靠加机器分担,ES 的缓存和求交算法才是对症的。方案是 MySQL 继续做权威库,列表查询切到每晚重建的 ES 只读索引,同时和产品对齐 10000 条翻页上限和「10000+」的总数展示。

判断要靠指标,不靠感觉。我们给这两个方向各设了一个信号:

信号指向
覆盖索引体积持续超过 Buffer Pool 的一半,或者加索引的 DDL 超过夜间窗口容量墙:分区归档,然后 TiDB
列表接口的 P99 被 COUNT 和中间页拖到秒级,且 QPS 在持续上涨算力墙:ES
只有 COUNT 慢,QPS 没涨都不换,先做第 2 篇第七节的 COUNT 缓存

✅ Checklist:决定迁 TiDB 或 ES 之前过一遍

  • 瓶颈是容量还是算力?用上面的信号表确认过了吗?
  • 如果只是 COUNT 慢,是否已经试过按「条件 + 同步批次号」缓存?
  • 迁 TiDB:主键是否改成了 AUTO_RANDOM?单调时间索引是否做了预切分?夜间同步是否已经按事务大小上限分批?
  • 迁 TiDB:是否扫过存储过程、触发器、依赖 AUTO_INCREMENT 连续性的代码?
  • 迁 TiDB:默认倒序列表的逆序扫描、大批量更新后的扫描,压测里覆盖了吗?
  • 上 ES:查询条件是否都放在 filter 里?
  • 上 ES:10000 条翻页上限和「10000+」总数展示,产品是否书面确认?
  • 上 ES:MySQL 是否依然是权威库?重建、切别名、回滚、对账、告警是否都有了?
  • 上 ES:分片数是否按数据体积定的,而不是按机器数定的?

写在最后:四篇文章,一条主线

回头看整个系列,每一篇其实都在做同一件事:看清一种存储结构消灭了什么代价,又留下了什么代价。

结构消灭了什么留下了什么
InnoDB 宽覆盖索引 + 延迟关联回表的随机 IO、filesort线性扫描、深分页、COUNT
LSM-Tree 分布式 KV随机写、大对象点查的磁盘 IO二级索引、offset、全量 Scan
Key-List + mGet 回表单主 ID 下长列表的过滤与网络开销必须带锚点,否则就是超级热点
TiDB单机容量上限、对分表键的依赖扫描总量、深分页、点查延迟
Elasticsearch最左前缀限制、多条件的重复计算深分页上限、精确 COUNT、同步链路

没有哪一种结构能把所有代价一起消灭。深分页和精确总数这两件事,从第 2 篇的 MySQL 一路跟到这一篇的 ES,换了四种存储都没有消失,因为它们的工作量本来就和数据量成正比。真正能让它们消失的,只有产品上的一句话:用户真的需要跳到第 8504 页、真的需要知道是 85041 条而不是「8 万+」吗?

存储选型能做的,是在问清楚这句话之后,选一个刚好够用的结构,并且清楚地知道它会在哪里先坏掉。


系列目录

  1. 第 1 篇 · 存储架构全景与选型边界推演(总纲)
  2. 第 2 篇 · 单机 MySQL 千万级台账任意翻页实战
  3. 第 3 篇 · 从 LSM-Tree 到列表引擎:分布式 KV 与 Key-List 底层原理
  4. 第 4 篇 · 突破单机极限:TiDB 全局索引与 ES 位图检索(本篇,完结)

👉 开源: Solo Workspace (独立开发者 CLI)· solo-spring-scaffold (Spring Boot 脚手架)

👉 其它平台: 知乎 · 掘金

👉 联系: [email protected] (合作 / 线上问题交流欢迎来信)