去年做过一个社交产品的小需求:给用户算「你可能认识的人」。规则很朴素,在我关注的人里面,找出他们共同关注、但我还没关注的人,按共同关注的人数排序,取前 20 个,接口 100ms 内返回。上线前我们以为这是个排序问题,做完才发现它是个存储问题。

同一个需求,我们前后写了四版:关系库的关联表、Redis 的集合、MongoDB 的内嵌数组、图数据库的两跳遍历。输入数据一模一样,查询写法完全不是一个东西。第一版四十多行 SQL,要建两个索引;第四版六行 Cypher,只声明关系和方向。这段经历让我改掉了一个很顺口的说法:不是数据长什么样决定用什么库,是你打算怎么查它,决定用什么库。

同一个需求,四种写法

先把数据摆出来。用户 3000 万,关注关系 2.4 亿条,平均每人关注 80 人,最大的运营号关注 2000 人,最大的网红有 500 万粉丝。需求只查二度:A 关注了 B,B 关注了 C,C 就是候选,最后排除掉 A 自己和他已经关注的人。

关系库的写法,一张 follow 表,两列分别是关注者和被关注者。二度人脉就是这张表和自己做一次 JOIN:

SELECT f2.followee_id, COUNT(*) AS common
FROM follow f1
JOIN follow f2 ON f1.followee_id = f2.follower_id
WHERE f1.follower_id = 1001
  AND f2.followee_id <> 1001
  AND NOT EXISTS (
    SELECT 1 FROM follow f3
    WHERE f3.follower_id = 1001
      AND f3.followee_id = f2.followee_id
  )
GROUP BY f2.followee_id
ORDER BY common DESC
LIMIT 20;

Redis 的写法是每个用户一个 Set,成员是他关注的人。二度要先把关注对象的 Set 求并集,顺便用权重算出「被几个人共同关注」。下面用三个关注对象举例,真实场景里关注 80 人,命令里就要列 80 个 key,命令长度和耗时都会跟着涨:

SADD follow:1001 2001 2002 2003
(integer) 3
SADD follow:2001 2003 2005 2008
(integer) 4
SADD follow:2002 2003 2007
(integer) 3
SADD follow:2003 2005 2007
(integer) 3
ZUNIONSTORE tmp:pymk:1001 3 follow:2001 follow:2002 follow:2003 AGGREGATE SUM
(integer) 4
ZREVRANGE tmp:pymk:1001 0 3 WITHSCORES
1) "2007"
2) "2"
3) "2005"
4) "2"
5) "2003"
6) "2"
7) "2008"
8) "1"
# 返回后在应用层去掉 follow:1001 里已有的成员,再取前 20

这里没有一个原生命令能直接完成「并集之后按集合过滤」,因为 Set 和 ZSet 是两个类型,差集命令要求两边类型一致,所以最后一步只能回到应用层做。

MongoDB 的写法是把关注列表内嵌在用户文档里,然后用聚合管道展开两层。核心是 $unwind 加 $lookup,再按候选分组计数。示例假设 A 关注了 2001、2002、2003,最后一步把 A 自己和这三个人都排除掉:

db.users.aggregate([
  { $match: { _id: 1001 } },
  { $unwind: "$following" },
  { $lookup: {
      from: "users",
      localField: "following",
      foreignField: "_id",
      as: "mid"
  } },
  { $unwind: "$mid" },
  { $unwind: "$mid.following" },
  { $group: { _id: "$mid.following", common: { $sum: 1 } } },
  { $match: { _id: { $ne: 1001, $nin: [2001, 2002, 2003] } } },
  { $sort: { common: -1 } },
  { $limit: 20 }
])
{ "_id" : 2007, "common" : 2 }
{ "_id" : 2005, "common" : 2 }
{ "_id" : 2008, "common" : 1 }

图数据库的写法最短。节点是用户,边是关注,方向从关注者指向被关注者。两跳就是沿着边连走两次,最后用模式匹配排除已经关注的人:

MATCH (me:User {id: 1001})-[:FOLLOWS]->(mid)-[:FOLLOWS]->(cand)
WHERE cand <> me AND NOT (me)-[:FOLLOWS]->(cand)
RETURN cand.id AS id, count(*) AS common
ORDER BY common DESC
LIMIT 20
id: 2007, common: 2
id: 2005, common: 2
id: 2008, common: 1

四段代码看起来只是语法不同,背后却是四种完全不同的排序方式。SQL 那一版把「怎么连」交给优化器现场决定;Redis 那一版把「谁能跟谁比」压进了集合运算;MongoDB 那一版把「一个人关注了谁」放在文档内部;图库那一版把「谁连着谁」直接变成了存储布局。

上面所有命令都没有在本机实测。本机没有装 Redis、MongoDB 和 Neo4j,代码是按各数据库当前版本的语法写的,只用于对比查询形状。真要跑,先按各家的官方安装步骤起一个单机实例。

模型的本质:为哪种查询预先排好序

所有存储引擎都在回答同一个问题:给定一个条件,怎么最快找到那批数据。索引是局部答案,数据模型是整个建筑的答案。你选了一种模型,等于告诉数据库「我以后主要按这个形状来查」,它就在写入的时候替你把数据按这个形状摆好。摆好是要花时间的,所以写入变慢、别的查询形状变难,都是这笔预付款的利息。

查询接口:允许多复杂的条件组合关系库给你通用 SQL,文档库给你 JSON 查询加聚合管道,键值只给你「按 key 取」,宽列只给你「分区键加排序键的范围」,图库只给你「从某个点出发沿边走」。
索引结构:除了主键还能从哪进去关系库可以按需给任意列建 B+ 树索引;文档库支持字段、复合、数组多键索引;宽列的「索引」就是排序键本身;图库的索引只用来找起点,遍历靠邻接表。
存储布局:数据按什么顺序落盘关系库按主键聚簇,宽列按分区键加排序键物理连续,图库把同一个节点的边放在一起,键值把整块值放在一起。

把这四层摆在一起看,四种模型的差别就很清楚了。关系库把排序留到运行时,代价是每次查询都要靠索引和优化器现场算;NoSQL 把排序写死在写入路径上,代价是查询形状一旦跑偏,就没有补救的余地。所谓「选型」,本质是在赌未来的查询会不会变。

键值与文档:一个是黑盒,一个是实体

这两类最常被放在一起比较,因为都「存一块东西」。但它们的边界完全不同。

键值:数据库只知道 key

value 是一整块,String、Hash、List、Set、ZSet 只是这块东西的几种形状。数据库不解析里面的内容,所以不存在「按 value 里某个字段查」这回事。

擅长的是按 key 读写整块、计数、过期、排行榜、集合交并差。卡住的地方是多条件查询:要按年龄找用户,就得再维护一个 user:age:30 的 Set,或者一个按年龄打分的 ZSet。写一次用户要同时更新五个 key,任何一步失败就不一致。这不是 Redis 的缺陷,是模型的选择,它把建索引这件事从数据库挪进了你的代码。

还有一个容易忽略的限制:集群模式下多 key 命令要求这些 key 在同一个 slot,否则直接报错。

文档:一次取回一个实体

集合加字段路径,查询是 JSON 形状的。一个商品四十个属性、不同品类还不一样,关系库要么开一堆空列,要么退回一行一个属性的 EAV 表,文档库直接把整份对象存进去。

它最关键的决策是内嵌还是引用。判断标准有三条:会不会一起读,数量有没有上限,要不要独立更新。订单里的商品行、文章下的标签,一起读、有上限,内嵌;用户的关注列表、评论,数量没上限、要独立翻页,引用。

内嵌的代价是文档会变大,每次更新重写整页,热点文档写放大;数组没有上限时索引也会膨胀。引用的代价是读的时候要二次查询,$lookup 本质上是每行回查一次,深分页时会很慢。

宽列与图:一个按坐标排,一个按邻居排

剩下两类更偏科,理解它们只需要抓住一句话:宽列把数据摆成一张巨大的有序表,图把数据摆成一张巨大的邻接表。

宽列:分区键加排序键

一张表就是一个按「分区键、排序键」排好序的映射。分区键决定这行落在哪台机器,排序键决定分区内部的顺序,普通列跟着这两个键一起连续存放。

擅长海量写入和按时间范围查。写入是追加,几乎不随机改页;查「某个用户最近三十条消息」时,同一分区的数据在磁盘上连着,一次顺序扫描就够。

卡住的地方很硬:查询必须带分区键,否则要么报错,要么扫全部节点;不能 JOIN;不能按普通列高效过滤,除非自己再维护一张索引表。分区也不能无限大,常见建议是单分区控制在一百兆、十万行以内,具体阈值随版本和硬件变化,待确认。最怕的是热点分区,按用户分区时,一个大 V 的所有粉丝写入会砸在同一个节点上。

图:邻接表就是索引

节点和边,边有方向、有类型,节点和边都能带属性。存储时把同一个节点的出边放在一起,遍历的时候顺着走,不需要为每一跳再查一次索引。

擅长多跳。二度人脉、三度推荐、最短路径、权限继承、反欺诈团伙,这些查询的共同点是「答案取决于连接形状,而不是某一行的大小」。

卡住的地方同样明显:全图扫描和聚合很弱;超级节点会让遍历爆炸,一个五百万粉丝的账号,边数就抵得上一张小表;数据量大时通常要全部放内存,成本高;边跨机器时分区很难做。它适合当关系查询的专用引擎,不适合当主存储。

一跳和二跳的成本差别,值得单独说一句。关系库每跳一次都要走一次索引、做一次 JOIN,成本跟表的规模和索引深度有关;图库每跳只是沿邻接表读下一批边,成本跟「实际访问到的边数」有关,跟总数据量关系不大。数据总量到几亿条时,这个差别会被放大成几十倍。

一次完整的场景走查:从 SQL 到图库

把需求从头到尾走一遍,每一步都记下数字和代价。这套数字来自一次真实上线的观察,不是本机跑出来的基准。

二度人脉的四次迭代
关系库 JOIN,P99 380ms
Redis 集合,18 到 35ms
文档内嵌,60 到 120ms
图库两跳,8 到 15ms

起点:MySQL 两张表,用户表和关注表,关注表 2.4 亿行,主键是关注者加被关注者,另建一个反向索引。上面那条 SQL,普通用户中间结果 80 乘 80 等于 6400 行,运营号 2000 乘 80 等于 16 万行。普通用户 P99 是 380ms,运营号 2.1 秒。产品要求 100ms,差得很远。

第一步,加结果缓存。离线任务每天算一次,把 20 个推荐 id 存进 Redis,key 是 pymk:{uid},过期 24 小时。3000 万用户乘 20 个 id 乘 8 字节,大约 4.8GB,加上 key 开销接近 8GB。命中率 94%,P99 降到 25ms。代价马上来了:新关注要等一天才生效,取关的人还会继续出现在推荐里。产品不接受这个延迟。

第二步,改成 Redis 实时算。每个用户一个关注 Set,2.4 亿条边。按 80 个整数元素估算,一个 intset 约 400 字节,3000 万个 Set 约 12GB,加上碎片和副本,实际吃了 30GB 内存。单次查询 18 到 35ms,看起来达标。但一次要动 80 个 key,集群模式下这些 key 不在同一个 slot,直接报 CROSSSLOT;加了 hash tag 把同一用户的 key 绑到一个 slot,又把这个用户的所有读集中到了一台节点,形成热点。

第三步,试 MongoDB 内嵌。用户文档里放一个 following 数组,聚合管道查两层。单次 60 到 120ms,因为 $lookup 对每个关注对象都要回查一次用户集合。而且「谁关注了我」还得另外存一个 followers 数组,两个数组要在关注和取关时同步更新。上线一周后我们把它下线了,它擅长的是「读一个实体」,不是「沿关系走」。

第四步,上了一个图库。3000 万节点、2.4 亿条边,全内存大约 30GB,这是按每个节点和每条边的固定开销估的,实际取决于属性数量。两跳查询 8 到 15ms,含「排除已关注」的模式匹配会随已关注人数变慢,80 个已关注时还能接受,运营号 2000 个就明显变慢,最后限制深度为二、候选上限 5000。

最终形态与代价:接口 P99 22ms,由三部分组成:离线算好的推荐结果、Redis 缓存、图库兜底。存储从四套减到两套加一套离线图库。关注和取关写 MySQL 后发一条消息,消费者去更新 Redis 和图库,失败进重试队列,每天凌晨对账,差异超过千分之一报警。两个全职投入三周,值班手册多了一本图库排障。原来一条 SQL 能解决的问题,现在需要四个组件、一条消息链路和一份对账脚本,这就是「选对模型」的账单。

不要因为图数据库「天生适合存关系」就把所有外键搬过去。绝大多数业务里的关系查询只有一跳,SQL 一次 JOIN 十毫秒就结束了,换图库只会多一套运维。只有当查询要沿着关系走两跳以上,或者路径形状本身是产品功能时,图库的收益才盖得住成本。

现象、原因与第一步排查

下面这张表是选型之后最容易撞上的一批现象。它不能替代具体排查,但能帮你判断「这是不是模型选错了」。

现象真实原因第一步查什么
文档库单文档更新越来越慢内嵌数组被撑大,每次更新重写整页,热点文档写放大查文档的 BSON 大小和数组长度,再看 WiredTiger 的脏页比例与 cache 淘汰
Redis 多 key 命令报 CROSSSLOT集群模式要求多 key 在同一 slot,key 名里没有 hash tag用 CLUSTER KEYSLOT 看几个 key 的槽位,给相关 key 加统一的 {tag}
宽列查询直接超时查询没带分区键,请求被广播到所有节点再归并看执行计划里的扫描范围,确认 WHERE 里有没有分区键
宽列某个节点负载明显偏高分区键选了大客户或大 V,写全部落在同一个分区看各节点的数据量和请求量分布,找最大的几个分区
图查询从两跳加到三跳就爆边数按度数指数增长,超级节点把遍历放大几百倍看单次查询访问的边数,给超级节点做截断或限制深度
文档聚合管道越来越慢$lookup 每行回查一次,关联字段没有索引用 explain 看检查的文档数和索引使用情况,能内嵌就改成内嵌
两套存储的数据对不上双写没有事务,同步失败没有补偿和重试查变更日志和重试队列,比对两边的更新时间与版本号

边界与代价:多套存储的账单

这套做法有个名字,叫 Polyglot Persistence,直译是「多语言持久化」:每种数据用最适合它的模型,听着很合理,账单也确实存在。

第一,多一套存储就多一套运维。备份策略、监控指标、版本升级、权限管理、容量规划、故障演练,每一样都要单独做一遍。四套存储的故障组合有六种,每一种都要有预案。MySQL 出问题有二十年的帖子可查,图库的锁等待和内存估算能查到的中文资料少得多。

第二,一致性只能自己兜。跨存储没有事务,常见做法是用变更日志加消息队列做同步,再写对账任务。CDC 有延迟,消息会重复也会乱序,消费者必须做成幂等。上线之后你会发现,真正的工作量不在查询,而在「怎么保证四份数据说的是同一件事」。

第三,模型改动的成本不对称。关系库改需求,往往加个索引或改条 SQL;文档、宽列、图的模型是按查询设计的,产品改一次查询形状,可能就要重建模型再回刷全量数据。宽列改分区键基本等于重做一张表。

第四,人力的门槛。一个人要同时会 SQL、Redis 命令、Mongo 聚合管道、Cypher、CQL,招聘和排障都变贵。团队只有三五个人时,多一套存储往往意味着每个人都得是半专家。

所以绝大多数项目不需要四种。真实系统里最常见的是两到三套:关系库兜住事务和主数据,Redis 兜住热点读和计数,再加一个搜索或文档库解决特定形状的查询。这个组合能覆盖八成场景,剩下的两成再单独评估。

判断该不该加一套存储,把这个问题写下来贴在墙上:这套新存储能解决的那个查询,用现有存储加索引或改写法,最坏要多少毫秒。如果答案是「几十毫秒」,那就不值得。

当天可以自己验证的练习

  1. 在本地 MySQL 建两张表模拟关注关系,灌十万条边,跑一遍上面那条二度 SQL,用 EXPLAIN 看扫描行数和实际返回行数的差距。
  2. 启动一个本地 Redis,给两个用户各建一个关注 Set,先用 SINTER 求共同关注,再用 ZUNIONSTORE 带权重求二度候选,比较两次返回的结构差异。
  3. 在 MongoDB 里把同一个用户写成「内嵌 following」和「引用 follows 集合」两种,各写一次「谁关注了我」的查询,数一数代码行数和查询耗时。
  4. 拿一张你熟悉的表,写出它最主要的五条查询,标出每条查询的入口条件,看看一共有几种不同的入口形状。
  5. 画一张你所在系统的存储地图,标出哪些数据存在两处以上,以及不一致时用户会看到什么。

小结

四种数据模型不是四个可以互相替换的选项,而是四种不同的预排序。键值只排 key,文档排字段路径,宽列排分区键加排序键,图排邻接关系。你选哪一个,取决于最主要的查询是「按 key 取一块」「取一个实体」「按坐标扫一段」还是「沿关系走几跳」。

模型选对能带来数量级的差别,但代价是通用性、一致性和运维复杂度。决定之前,先把查询形状数清楚,再算一遍多一套存储的账单,最后才看 benchmark。

下一篇讲Redis 上手与常用数据结构。四种模型里,键值是最容易先落地的一类,因为它不需要重构实体,只要把「一次读写整块」的东西挪出去。而 Redis 是键值里最好上手的入口,它那五种数据结构,其实就是五种预先排好序的方式。