去年接过一个商品后台,主表叫 products,四十七列。前二十列是通用的:标题、品牌、类目、价格、库存。后面二十七列是给不同品类用的:衣服有「领型」「袖长」「面料成分」,家电有「能效等级」「额定功率」「噪音值」,食品有「保质期」「配料表」「储存条件」。结果是每一行都有大半的列是 NULL,唯一索引还得绕开这些空值。

新产品线一进来,产品经理发来一张新的属性清单:「这次是户外装备,加九个字段。」于是又是一次 ALTER TABLE,又是一次发版,又是 DBA 排窗口。干了两次之后,团队换了个方案:把属性从列挪到行,建一张 product_attributes(product_id, attr_key, attr_value)。这就是 EAV(Entity-Attribute-Value),实体、属性名、属性值各占一列,加新属性只需要插数据,不用改表。

方案换完,表结构是稳了,查详情页的 SQL 却变成了这样:先 SELECT 主表,再对属性表按 product_id 取出几十行,在应用层拼成一个对象;如果列表页要按「颜色=黑 且 尺码=XL」筛选,就得写两个子查询 EXISTS,或者三次 JOIN 同一张表。商品两百万行、属性行六千多万行的时候,一个筛选列表页的 P99 是 900 毫秒,慢查询日志里排第一。

这篇讲的就是从这里往后走的路:把「一个商品」当成一整份文档来读写,会是什么样。全文的命令都需要在 mongosh 里执行,但我本机没有装 MongoDB,所有输出是按 MongoDB 6.0/7.0 的行为写的预期结果,未在本机实测;你照着敲,数字和文案可能略有出入,结构应该一致。

EAV 的痛,不在存储,在拼装

先说清楚 EAV 到底哪里慢,免得把结论记成「关系库不行」。EAV 的设计没有错,它把「列不固定」这件事转成了「行不固定」,表结构因此稳定,加属性不用改表。代价是三笔,而且每一笔都会随数据量放大。

第一笔:一次读要拼几十次取一个商品详情,主表一行加属性表四十行,应用层要循环拼装。数据库层面其实只有两次查询,但两次查询之间的行数比例是 1:40,网络往返和反序列化的成本落在应用服务器上,不在数据库上。所以你扩数据库机器没用。
第二笔:筛选靠子查询堆按两个属性筛,就要两个 EXISTS 子查询;按属性排序,得先把行转成列。属性越多,执行计划越像一张网。优化器能用的只有 (attr_key, attr_value) 这一条索引,多条件筛完还要回主表取标题和价格。
第三笔:值的类型全丢了attr_value 只能存字符串或者一个大 VARCHAR。「价格」存成 "199.00" 之后,想按数值范围筛就得靠函数转换,索引直接失效;「上市日期」同理。类型约束从数据库挪到了代码里,写错一个格式,查询就悄悄少返回几行。

文档模型的想法很直接:既然一个商品在业务上就是一个整体,读的时候也总是一起读,那就把它存成一个整体。属性不是列也不是行,而是文档里的一个数组;不同品类字段不同,那就让它们真的不同,不需要为不存在的字段留位置。

{
  _id: ObjectId("65f1a2b3c4d5e6f708091a2b"),
  sku: "TS-2024-BLK-XL",
  title: "重磅纯棉圆领短袖",
  category: "apparel",
  price: NumberDecimal("129.00"),
  stock: 320,
  attrs: [
    { k: "领型", v: "圆领" },
    { k: "袖长", v: "短袖" },
    { k: "面料成分", v: "棉 100%" },
    { k: "尺码", v: "XL" }
  ],
  updated_at: ISODate("2026-03-01T09:12:00Z")
}

这份文档的结构,和详情页要渲染的结构基本一致。读一个商品是一次按 _id 的查询,返回一份完整对象,不需要拼装。这是文档模型真正卖的东西:把「读一次要拼多少次」降到一次。后面所有的取舍,都是围绕这句话展开的。

先连上,把增删改查跑通

不急着讲建模,先把最常用的几条命令跑一遍,手上有感觉了再看设计。启动本地实例后,用 mongosh 连进去。默认端口 27017,连上之后提示符是一个 >,前面会打印版本号和 shell 版本。

mongosh "mongodb://127.0.0.1:27017"
# 预期输出(未在本机实测):
# Current Mongosh Log ID: 65f1a2b3c4d5e6f708091a2b
# Connecting to:          mongodb://127.0.0.1:27017/?directConnection=true
# Using MongoDB:          7.0.5
# Using Mongosh:          2.2.2

注意 mongosh 和老的 mongo shell 不是同一个东西,前者是基于 Node.js 的,语法上更像 JavaScript,支持 await。然后看库、选库、插数据:

show dbs
# admin   40.00 KiB
# config  60.00 KiB
# local   72.00 KiB

use shop
# switched to db shop

db.products.insertMany([
  {
    sku: "TS-001", title: "纯棉短袖", category: "apparel",
    price: NumberDecimal("129.00"), stock: 320,
    attrs: [{ k: "颜色", v: "黑" }, { k: "尺码", v: "XL" }],
    tags: ["新品", "夏季"], created_at: new Date("2026-02-01")
  },
  {
    sku: "HD-002", title: "降噪头戴耳机", category: "digital",
    price: NumberDecimal("899.00"), stock: 45,
    attrs: [{ k: "颜色", v: "白" }, { k: "续航", v: "30h" }],
    tags: ["热销"], created_at: new Date("2026-02-11")
  }
])
# {
#   acknowledged: true,
#   insertedIds: {
#     '0': ObjectId("65f1a2b3c4d5e6f708091a2c"),
#     '1': ObjectId("65f1a2b3c4d5e6f708091a2d")
#   }
# }

use shop 之后库并不立刻存在,第一次写入才会真正建库建集合。这一点和 MySQL 不同,别在 show dbs 里找 shop 找不到就以为连错了。

查的时候,第二个参数是投影,控制返回哪些字段;排序和条数用链式 sort() 与 limit()。列表页只要卡片信息时,把 attrs 排掉,体积能小一半:

db.products.find(
  { category: "apparel", price: { $lte: NumberDecimal("200.00") } },
  { sku: 1, title: 1, price: 1, _id: 0 }
).sort({ created_at: -1 }).limit(5)

# 预期输出(未在本机实测):
# { sku: 'TS-001', title: '纯棉短袖', price: Decimal128('129.00') }

改,有三种粒度。只改一个字段用 $set;要数值累加用 $inc;往数组尾部追加用 $push。这三个操作符都很重要,因为它们只发送变化的部分,而不是把整份文档读出来改完再写回去:

db.products.updateOne(
  { sku: "TS-001" },
  {
    $set: { title: "纯棉短袖(2026 版)" },
    $inc: { stock: -3 },
    $push: { tags: "补货" }
  }
)
# { acknowledged: true, insertedId: null, matchedCount: 1, modifiedCount: 1 }

db.products.deleteOne({ sku: "HD-002" })
# { acknowledged: true, deletedCount: 1 }
matchedCount 是「命中几条」,modifiedCount 是「实际改了几条」。如果 matchedCount 是 1 而 modifiedCount 是 0,说明新值和旧值一样,或者 $set 的目标路径写错了大小写。这两个数字是排查更新类问题最快的入口。

最后是聚合。MongoDB 的聚合管道用一串 stage 描述处理过程,$match 筛、$unwind 拆数组、$group 分组,写法和 SQL 的 WHERE / GROUP BY 是对应的,只是顺序由你排:

db.products.aggregate([
  { $match: { category: "apparel" } },
  { $unwind: "$attrs" },
  { $match: { "attrs.k": "颜色" } },
  { $group: { _id: "$attrs.v", count: { $sum: 1 } } },
  { $sort: { count: -1 } }
])

# 预期输出(未在本机实测):
# [ { _id: '黑', count: 128 }, { _id: '白', count: 96 } ]

管道里两个 $match 的位置很讲究。第一个放在最前面,是为了尽早用上 category 的索引;第二个必须放在 $unwind 之后,因为在拆开之前 attrs.k 是一个数组,直接比较会变成「数组里有没有这个元素」的语义,结果不对。这类顺序问题会在下面那张表里再出现一次。

ObjectId:不是自增 ID,但大致有序

没有指定 _id 的时候,驱动会生成一个 ObjectId,长这样:ObjectId("65f1a2b3c4d5e6f708091a2c")。二十四位十六进制,拆开是三段:

字节位置内容作用
0–3(4 字节)Unix 时间戳,秒决定整体顺序,所以同一秒内插入的文档会挨在一起
4–8(5 字节)机器标识 + 进程标识同一台机器、不同进程生成的 ID 不会撞
9–11(3 字节)进程内自增计数器同一进程同一秒内最多 16777216 个

经常有人问「ObjectId 能不能当订单号」。不能:两台机器同一秒生成的 ID,大小取决于机器标识那 5 个字节,和时间无关;而且它带着生成时间,暴露在 URL 里等于告诉别人这条记录什么时候建的。对外展示的编号自己生成。

但它有一个很好用的性质:按 _id 排序约等于按插入时间排序。做「最近创建的十条」这类查询,用 _id 倒序就够了,不必额外建 created_at 索引。代价是精度只到秒,同一秒内的顺序靠机器和计数器,跨机器就不可靠。

不要用字符串拼一个「时间 + 随机数」当 _id,除非你确定它单调递增。随机字符串做主键会让每次插入落在 B 树的不同位置,缓存命中率下降,写入越跑越慢。

建模的核心只有一道题:内嵌还是引用

关系库里,两个实体有关系就建外键,读的时候 JOIN。文档库里没有这个默认答案,你得在建模时决定:这份子数据是塞进父文档里,还是单独一个集合、父文档存个 id。判断依据不是「关系是一对多还是多对多」,而是三个更实际的问题:会不会一起读、子数据会不会无限长、子数据会不会被别的父级共享。

内嵌:一次读完,代价是文档会长大

适合「父子总是一起读、子数据有上限、只属于这一个父级」的情况。商品属性、订单里的收货地址快照、文章的作者信息副本,都属于这类。读是一次查询,写也是一次原子写,不需要事务。代价是子数据重复存储(同一份作者信息在每篇文章里各存一份),且数组一旦无界增长,文档会膨胀到影响读写。

引用:分开存,代价是要自己拼

适合「子数据数量不确定、会单独查询、会被多个父级共享」的情况。评论、订单明细里指向的商品、关注列表,都属于这类。分开存的好处是文档大小可控、可以单独分页、可以有自己的索引。代价是一次读要两次查询,跨文档的写没有原子性,要么用事务,要么在应用层补偿。

落到具体的关系类型上,经验是这样:1:1 基本都内嵌,除非子文档很大且不常读;1:N 且 N 有明确上限(比如一个商品最多二十个属性、一个用户最多五个地址),内嵌;1:N 且 N 会一直涨(评论、日志、消息),引用,并且把「多数」放在子集合里,父文档只存计数;N:N 一律引用,两边各存对方的 id 数组,数组本身也要设上限。

有一条硬限制必须记住:单个文档上限 16MB。这不是配置项,是 BSON 格式和存储引擎的约定。粗略换算,16MB 能装下几万条短文本记录,听起来很多,但图片 base64、无界增长的数组、越来越长的历史快照,都会在几个月内把它顶满。真到那一天,写入会直接报错,而不是慢慢变慢。

还有一笔容易被忽略的成本:字段名会被重复存储。MongoDB 不存表结构,每个文档自己带一份字段名。你把字段叫 product_attribute_value,两百万个文档就存了两百万遍这 23 个字符。经验做法是:集合文档量大时,字段名尽量短(attrs、v、k),把可读性留在代码的映射层,而不是留在存储里。这笔节省在百万级文档上通常能到百分之十几的磁盘。

场景走查:把商品目录从 EAV 搬到文档

回到开头那个后台。设定是:两百万商品,六千三百万属性行,详情页峰值 3000 QPS,列表页筛选 800 QPS,商品每天更新约 5 万次。目标是把详情页 P99 从 900ms 降到 100ms 以内,筛选页从 900ms 降到 200ms 以内,同时不再为加属性发版。

第一步,定文档结构。商品主体一个文档,属性内嵌成数组,评论拆到独立集合。属性用 k/v 两个短字段名,另外加一个 attrs_map 对象,把常用属性平铺出来给范围查询用:

// 集合 products
{
  _id: ObjectId("..."),
  sku: "TS-001",
  title: "纯棉短袖",
  category: "apparel",
  brand: "自有品牌",
  price: NumberDecimal("129.00"),
  stock: 320,
  attrs: [
    { k: "颜色", v: "黑" },
    { k: "尺码", v: "XL" },
    { k: "面料成分", v: "棉 100%" }
  ],
  attrs_map: { "颜色": "黑", "尺码": "XL" },
  rating: 4.7,
  review_count: 128,
  updated_at: ISODate("2026-03-01T09:12:00Z")
}

// 集合 reviews,通过 product_id 引用
{
  _id: ObjectId("..."),
  product_id: ObjectId("..."),
  user_id: 10086,
  score: 5,
  content: "面料厚实,尺码偏大",
  created_at: ISODate("2026-02-28T13:40:00Z")
}

为什么要同时存数组和对象?因为两种形状服务两种查询:数组保持顺序,适合「有哪些属性」的展示,也方便 $elemMatch 判断同一个元素是否同时满足多个条件;attrs_map 适合「颜色=黑 且 尺码=XL」这类多条件筛选,一个复合索引就能覆盖。

第二步,建索引。只建三条,每条都对应一个真实查询,不为「以后可能用到」建索引:

db.products.createIndex({ sku: 1 }, { unique: true })
db.products.createIndex({ category: 1, "attrs_map.颜色": 1, price: 1 })
db.products.createIndex({ category: 1, updated_at: -1 })
db.reviews.createIndex({ product_id: 1, created_at: -1 })

第三步,迁移数据。写一个一次性脚本,从 MySQL 按 product_id 分页读主表,再按批取属性行,在内存里拼成文档,用 insertMany 每批一千条写入。六百三十万属性行、两百万商品,第一次跑用了 6 小时 40 分,平均每秒写入约 83 个文档。慢的原因不是 MongoDB 写不动,而是源库的 EAV 查询本身要按 product_id 范围取几十行,源库磁盘 IO 先到顶了。

第四步,灰度切读。先让详情页 10% 的流量读 MongoDB,比对两边返回的字段差异。第一轮比对发现 3.2% 的商品属性对不上,原因是有 1200 条属性行的 attr_key 前后带了空格,迁移脚本没 trim。修掉之后差异降到 0.01%,剩下的都是源库本身就有的脏数据。灰度跑了一周,详情页 P99 从 900ms 降到 68ms,筛选页从 900ms 降到 190ms。

代价账单。读变快了,写变贵了。同一次商品编辑,原来更新主表一行加删插属性行若干,现在要重写整份文档:MongoDB 的更新会记 opLog、写新版本、旧空间等 checkpoint 之后才回收。日更 5 万次、单文档平均 6KB 的情况下,写入放大大约是原来的 2.5 倍,磁盘占用从 41GB 涨到 128GB(含索引和预分配空间)。另外多了两套存储,商品改价时 MySQL 和 MongoDB 都要写,团队补了一个基于 binlog 的同步任务,延迟 200ms 以内,但对账脚本是跑不掉的。

结果与代价放在一起看。读延迟降了一个数量级,加属性不再发版,代价是存储成本翻了三倍、多了一条同步链路、以及团队要开始学着看 explain 和 serverStatus。如果这个后台只有十万商品、QPS 个位数,这笔账是划不来的——这也是为什么下一篇要讲索引和分片:数据量不到那个位置,文档模型的收益盖不住它的运维成本。

查不到、查得慢、写不下:一张排查表

迁移上线之后的三个月,团队踩到的坑基本都能归到下面这几类。它们的共同点是:报错信息不会告诉你原因,只会给你一个空数组或者一个慢查询。

现象真实原因第一步查什么
明明有数据,find 返回空数组字段名大小写不一致(Price 和 price 是两个字段);数字存成了字符串 "129";日期是字符串而不是 ISODate用 db.products.findOne({ sku: "TS-001" }) 打印整份文档,肉眼核对字段名和值的类型,再用 $type 统计
按数组里的对象筛,条件明明只满足一半却返回了没用 $elemMatch,{"attrs.k":"颜色","attrs.v":"黑"} 会被拆成「数组里有 k=颜色 的元素」且「数组里有 v=黑 的元素」,两个可以来自不同元素把条件改成 { attrs: { $elemMatch: { k: "颜色", v: "黑" } } },对比命中数量
查询从 20ms 变成 2s没走索引,或在索引字段上用了正则、$where、$expr;LIKE '%x%' 式的模糊匹配在文档库里同样要全表扫跑 explain("executionStats"),看 totalDocsExamined 是不是远大于 nReturned
文档越来越大,写入报 16MB 超限数组无界增长(把每条浏览记录、每次改价历史都 $push 进商品文档)用 $bsonSize 聚合算出最大文档体积,检查有没有只增不减的数组
两个并发编辑互相覆盖,后写的把前一个的改动冲掉应用层「读出来、改字段、整份写回」,中间没有任何版本校验看写回用的是 replaceOne 还是 updateOne 加 $set,再决定是否引入 version 字段做乐观锁
$lookup 比原来的 JOIN 还慢$lookup 是逐条去外部集合查,没有哈希连接;被查集合如果没索引,复杂度直接变成笛卡尔积确认 foreignField 上有索引,再看 $lookup 前面是否已经用 $match 把主集合缩到很小
写入吞吐随索引数量线性下降每条写要更新每个索引的 B 树,还要写 opLog 和 journal;十个索引意味着一份文档写十一次db.products.getIndexes() 数一下索引个数,再看 serverStatus 里的写入延迟

这张表里最值得记住的是第一条。文档库没有 schema,也就没有「字段名写错时数据库替你报错」这层保护:关系库里 SELECT * FROM t WHERE prcie = 1 会直接报列不存在,文档库里它只会安静地返回空。实际项目通常会在应用层加一层 schema 校验,补上这层保护。

边界与代价:它替不了什么

没有真正的 JOIN。$lookup 只是个语法糖,实现上是嵌套循环,左边有多少条就查右边多少次。两边的数据量一大,它比关系库的哈希连接慢一个量级。文档模型的正解是「建模时就把要一起读的数据放在一起」,而不是「先按范式存,查的时候再连」。如果你的业务天然需要按任意维度关联,文档库会让你很难受。

多文档事务有,但别当默认选项。MongoDB 4.0 起支持副本集上的多文档事务,4.2 起支持分片集群事务。但事务持有锁、增加延迟、在分片集群上还要跨分片协调,官方文档自己也建议「用内嵌文档减少跨文档写」。能用一次原子写解决的事,不要用事务解决;确实要事务的场景(扣库存加记账),就老老实实包起来,并且接受它的性能上限。

无 schema 不等于不用设计。这句话在文档库上体现得最彻底:字段名、类型、嵌套层级、数组上限,全都要靠人约定。没有约定的结果是同一个集合里躺着五种形状的文档,三个月后没人知道哪种是对的。实际项目里的做法是:用一层集中的模型定义收口,写入口做校验,读出口做兼容,再配一个定期扫全集的形状统计脚本。

备份和恢复的工具链不一样。mongodump 适合小库和单集合导出,逻辑备份慢,恢复时索引要重建;大库要用文件系统快照或者 mongodump --oplog 保证时间点一致。副本集可以做时间点恢复,但要开 oplog 并算好窗口大小,默认的 oplog 在写入量大时可能只留几个小时。这些和 MySQL 的 mysqldump / XtraBackup 是两套完全不同的操作习惯,值班的人得重新学。

不要把 MongoDB 当缓存用。它没有 Redis 那种「过期即删」的低成本淘汰,大量短生命周期文档会留下空洞,需要靠后台任务清理。缓存就该放缓存,文档库负责的是「结构可变但需要持久化和查询」的那类数据。

小结

这篇的主线是一条:EAV 把结构问题转成了行数问题,文档模型把行数问题又转回了结构问题,只是这次结构放在应用侧。它换来的是一次读一份文档、加字段不发版;付出的代价是文档膨胀要自己控、JOIN 要自己避、schema 要自己守。

如果你现在就在一个字段越来越多的表前面犹豫,先用三个问题判断:这张表的读是不是总以「一个实体」为单位;子数据的数量有没有天然上限;加字段的频率是不是已经高到要排队发版。三个都答「是」,文档模型值得试;有一个答「否」,先把索引和查询写好更划算。

当天可以自己验证的练习:

  1. 用 Docker 起一个 mongo:7,连上去执行本文第二节的全部命令,把每条的真实输出和文中标注的预期结果对比,记下差异。
  2. 造 100 个商品,其中一半的 price 存成字符串,用 { price: { $lte: 200 } } 查一遍,再用 $type 统计,看结果为什么不对。
  3. 对同一个数组字段查询,分别写「点号条件」和 $elemMatch,构造一条「k 和 v 来自不同元素」的数据,对比两种写法的返回结果。
  4. 用 explain("executionStats") 跑一次不带索引的查询和一次带索引的查询,记录 totalDocsExamined 与 nReturned,算出扫描放大倍数。
  5. 写一段脚本,往一个文档的数组里连续 $push 十万条小记录,用 $bsonSize 观察文档体积增长,估算多久会碰到 16MB。

下一篇讲文档模型、索引与分片。能写能查只是开始:当集合从两百万涨到两亿,真正决定响应时间的是索引有没有被用上、分片键有没有把写入摊开。那时候你会发现,本篇里「建三条索引」的轻描淡写,其实是最容易埋雷的一步。