梅特尔恐怖逃生
64.25M · 2026-03-22
如果你正在阅读这份手册，说明你即将踏上一段激动人心的旅程。在2026年的今天，数据已经成为新时代的石油，而MongoDB则是开采、提炼和存储这些石油最高效的钻井平台之一。
作为初学者，你可能听说过关系型数据库（如MySQL、PostgreSQL），它们像Excel表格一样，用行和列来组织数据，严格且规范。而MongoDB则完全不同，它更像是一个灵活的JSON文档仓库。在这里，数据以自然的、层次化的结构存在，没有僵硬的表结构束缚，能够随着你的业务需求自由生长。
在开始之前，让我们先回答一个核心问题：为什么全世界有数百万开发者和企业选择MongoDB？
开发者友好（Developer Friendly）：
灵活的架构（Flexible Schema）：
强大的扩展能力（Scalability）：
多功能合一（Multi-Model）：
高可用性与云原生：
这份手册专为零基础或仅有少量SQL经验的初学者设计。我们将摒弃枯燥的理论堆砌，采用**“概念讲解 + 代码实战 + 避坑指南 + 最佳实践”**的模式。
学习目标： 读完本手册，你将能够：
准备好了吗？让我们开始吧！
要学好MongoDB，首先要完成一次思维模式的“格式化”。如果你习惯了SQL，请暂时忘掉“表”、“行”、“列”、“外键”这些概念。
| 关系型数据库 (RDBMS) | MongoDB (文档数据库) | 解释 |
|---|---|---|
| Database (数据库) | Database (数据库) | 数据的容器，逻辑隔离单元。 |
| Table (表) | Collection (集合) | 文档的分组。类似于表，但没有固定的列定义。 |
| Row (行) | Document (文档) | 数据的基本单元。类似于行，但是是JSON格式的。 |
| Column (列) | Field (字段) | 文档中的键值对。类似于列，但每个文档可以不同。 |
| Primary Key (主键) | _id (主键) | 每个文档必须有的唯一标识符。默认自动生成。 |
| Index (索引) | Index (索引) | 加速查询的数据结构，原理相似。 |
| Join (连接) | $lookup / Embedding | MongoDB不推荐频繁Join，提倡嵌入或应用层关联。 |
| Transaction (事务) | Transaction (事务) | 4.0+版本支持多文档ACID事务。 |
文档是MongoDB的核心。它是一个由键值对组成的数据结构，类似于JSON对象，但在底层存储为BSON（Binary JSON）。
JSON示例：
{
"_id": "67d8a1b2c3d4e5f6a7b8c9d0",
"name": "张三",
"age": 28,
"is_active": true,
"tags": ["developer", "mongodb", "golang"],
"address": {
"city": "北京",
"district": "海淀区",
"street": "中关村大街1号"
},
"created_at": "2026-03-20T10:00:00Z"
}
关键特点：
address）和数组（如tags）。这使得表达复杂关系非常自然。age可以是数字，文档B的age可以是字符串（虽然不建议这样做，但技术上允许）。_id字段。如果你不指定，MongoDB会自动生成一个ObjectId（12字节的唯一ID）。集合是文档的容器。
name字段的文档，再插入一个包含name, age, email的文档。 字符，通常以小写字母开头，不使用保留字（如system）。推荐使用复数名词，如users, products, orders。BSON是Binary JSON的缩写。它是MongoDB内部存储和网络传输的数据格式。
Date：精确的时间类型。BinData：二进制数据（存图片、文件）。ObjectId：自动生成的唯一ID。Regex：正则表达式。Int32, Int64：区分整数精度。工欲善其事，必先利其器。我们有三种方式来体验MongoDB。
这是最快、最无痛的方式。Atlas是MongoDB官方的全托管云服务。
0.0.0.0/0允许所有IP，仅限学习）。mongodb+srv://<username>:<password>@cluster0.xxxxx.mongodb.net/?retryWrites=true&w=majority优点：无需安装，开箱即用，包含坚控、备份功能。 缺点：依赖网络，免费层有资源限制。
如果你想在本地离线运行，Docker是最干净的方式。
docker run -d --name mongodb-local
-p 27017:27017
-v mongo-data:/data/db
mongo:8.0
mongodb://localhost:27017优点：本地运行速度快，环境隔离，易于清理。 缺点：需要懂一点Docker命令。
前往 mongodb.com/download-ce… 下载对应操作系统的安装包。
sudo apt-get install gnupg curl
curl -fsSL | sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg --dearmor
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] jammy/mongodb-org/8.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list
sudo apt-get update
sudo apt-get install -y mongodb-org
sudo systemctl start mongod
mongosh是官方的命令行交互工具，类似于MySQL的mysql客户端。它是学习MongoDB查询语法的最佳场所。
安装与连接：
如果使用了Docker，可以进入容器执行，或者在宿主机安装mongosh。
# 连接到本地
mongosh mongodb://localhost:27017
# 连接到Atlas
mongosh "mongodb+srv://user:pass@cluster0..."
Shell基本操作：
// 切换数据库（如果不存在，插入数据时会自动创建）
use my_first_db
// 查看当前数据库
db
// 查看当前数据库的所有集合
show collections
// 插入第一个文档
db.users.insertOne({
name: "Alice",
age: 25,
hobby: ["reading", "coding"]
})
// 查询所有文档
db.users.find()
// 格式化输出（更美观）
db.users.find().pretty()
对于新手，图形化界面（GUI）能极大降低学习曲线。MongoDB Compass是官方提供的免费GUI工具。
建议：在学习初期，同时使用mongosh（理解语法）和Compass（直观验证），效率最高。
掌握了基本概念后，我们来深入MongoDB的核心操作：CRUD（Create, Read, Update, Delete）。MongoDB的API设计非常直观，几乎就是英语句子的直译。
insertOne()db.products.insertOne({
name: "MacBook Pro 2026",
category: "Electronics",
price: 1999.99,
stock: 50,
specs: {
cpu: "M5 Chip",
ram: "32GB",
storage: "1TB SSD"
},
tags: ["laptop", "apple", "premium"],
createdAt: new Date()
})
acknowledged: true和插入文档的_id。_id如果没有提供，MongoDB会自动生成一个ObjectId。你也可以自定义_id，但必须保证唯一。insertMany()一次性插入多个文档，效率更高，且具有原子性（要么全成功，要么全失败）。
db.products.insertMany([
{ name: "iPhone 18", price: 999, stock: 100 },
{ name: "iPad Air", price: 599, stock: 80 },
{ name: "AirPods Pro", price: 249, stock: 200 }
])
查询是数据库最常用的操作。MongoDB使用find()方法。
db.products.find()
// 查找价格为999的产品
db.products.find({ price: 999 })
// 查找类别为Electronics且库存大于50的产品
db.products.find({
category: "Electronics",
stock: { $gt: 50 }
})
MongoDB提供了丰富的操作符，都以$开头。
比较操作符：
$eq: 等于（默认可省略）$ne: 不等于$gt: 大于 (Greater Than)$gte: 大于等于$lt: 小于 (Less Than)$lte: 小于等于$in: 在数组中$nin: 不在数组中// 价格大于500且小于2000
db.products.find({ price: { $gt: 500, $lt: 2000 } })
// 类别是Electronics或Books
db.products.find({ category: { $in: ["Electronics", "Books"] } })
逻辑操作符：
$and: 与（默认隐含，多个条件写在一起就是and）$or: 或$not: 非$nor: 或非// 价格低于100 或者 库存为0
db.products.find({
$or: [
{ price: { $lt: 100 } },
{ stock: 0 }
]
})
元素操作符（针对数组和字段存在性）：
$exists: 字段是否存在$type: 字段类型检查$size: 数组长度$elemMatch: 数组元素匹配（重要！）// 查找有discount字段的文档
db.products.find({ discount: { $exists: true } })
// 查找tags数组长度为3的文档
db.products.find({ tags: { $size: 3 } })
// 查找specs中ram为32GB的产品 (嵌套查询)
db.products.find({ "specs.ram": "32GB" })
// 高级：查找数组中包含特定对象元素的文档
// 假设comments数组: [{user: "A", rating: 5}, {user: "B", rating: 3}]
// 查找有用户A打分5的评论
db.products.find({
comments: {
$elemMatch: { user: "A", rating: 5 }
}
})
正则表达式：
// 名字以"Mac"开头，不区分大小写
db.products.find({ name: { $regex: /^mac/i } })
默认find()返回整个文档。为了性能，应只查询需要的字段。
语法：find(query, projection)。1表示包含，0表示排除。
// 只返回name和price，不返回_id (默认_id总是返回，除非显式排除)
db.products.find(
{ category: "Electronics" },
{ name: 1, price: 1, _id: 0 }
)
// 排除specs字段
db.products.find({}, { specs: 0 })
sort(): 排序。1升序，-1降序。limit(): 限制返回数量。skip(): 跳过数量（用于分页，但大数据量下性能差，见后文）。// 按价格降序排列，取前5个
db.products.find()
.sort({ price: -1 })
.limit(5)
// 分页：第2页，每页10条
const page = 2;
const pageSize = 10;
db.products.find()
.sort({ createdAt: -1 })
.skip((page - 1) * pageSize)
.limit(pageSize)
countDocuments() vs estimatedDocumentCount()countDocuments({query}): 精确计数，扫描匹配文档，慢但准。estimatedDocumentCount(): 基于元数据估算，极快，但不精确（适合显示“约有多少条”）。MongoDB提供强大的更新操作符，可以修改文档的特定字段，而无需替换整个文档。
updateOne()语法：db.collection.updateOne(filter, update, options)
$set: 设置字段值（字段不存在则创建）。
// 将iPhone 18的价格改为899
db.products.updateOne(
{ name: "iPhone 18" },
{ $set: { price: 899 } }
)
$unset: 删除字段。
// 移除discount字段
db.products.updateOne(
{ name: "iPhone 18" },
{ $unset: { discount: "" } } // 值无所谓，通常填空串
)
$inc: 原子自增/自减（非常适合计数器）。
// 库存减1
db.products.updateOne(
{ name: "iPhone 18" },
{ $inc: { stock: -1 } }
)
$push / $pop / $pull: 数组操作。
// 添加一个新标签
db.products.updateOne(
{ name: "iPhone 18" },
{ $push: { tags: "new_arrival" } }
)
// 从数组中移除特定值
db.products.updateOne(
{ name: "iPhone 18" },
{ $pull: { tags: "old_style" } }
)
// 仅添加不重复的值 ($addToSet)
db.products.updateOne(
{ name: "iPhone 18" },
{ $addToSet: { tags: "best_seller" } }
)
$rename: 重命名字段。
db.products.updateOne(
{ name: "iPhone 18" },
{ $rename: { "specs.cpu": "specs.processor" } }
)
updateMany()// 将所有Electronics类别的产品打折9折
db.products.updateMany(
{ category: "Electronics" },
{ $mul: { price: 0.9 } } // $mul是乘法操作符
)
replaceOne()这会保留_id，但替换掉其他所有字段。慎用，容易丢失数据。
db.products.replaceOne(
{ name: "Old Product" },
{ name: "New Product", price: 100 } // 其他字段全部消失
)
upsert: true: 如果文档不存在，则插入一个新文档。
// 如果找不到user: "Bob"，则创建它
db.users.updateOne(
{ username: "Bob" },
{ $set: { lastLogin: new Date() } },
{ upsert: true }
)
arrayFilters: 更新数组中满足特定条件的元素（2026年常用）。
// 将comments数组中所有user为"Alice"的rating改为5
db.products.updateOne(
{ _id: ObjectId("...") },
{ $set: { "comments.$[elem].rating": 5 } },
{ arrayFilters: [{ "elem.user": "Alice" }] }
)
deleteOne()// 删除第一个匹配的产品
db.products.deleteOne({ name: "Old Model" })
deleteMany()// 删除所有库存为0的产品
db.products.deleteMany({ stock: 0 })
// 清空集合（慎用！）
db.products.deleteMany({})
在生产环境中，永远不要物理删除重要数据。建议使用“软删除”：
isDeleted字段或deletedAt时间戳。deletedAt设为当前时间。deletedAt存在的文档。// 软删除
db.products.updateOne(
{ _id: id },
{ $set: { deletedAt: new Date() } }
)
// 查询时排除已删除
db.products.find({ deletedAt: { $exists: false } })
对于新手来说，如何设计数据结构是最大的挑战。在关系型数据库中，我们被教导要规范化（Normalization），把数据拆分成多张表，用外键连接。而在MongoDB中，策略完全不同。
Golden Rule: Your data model should be driven by your queries. (你的数据模型应该由你的查询驱动)
在设计集合结构之前，先问自己：
将相关数据存储在同一个文档中。
场景：
示例：博客文章与评论（评论较少时）
{
"_id": "post_1",
"title": "MongoDB入门",
"content": "...",
"author": "Alice",
"comments": [
{ "user": "Bob", "text": "写得真好", "date": "2026-03-20" },
{ "user": "Charlie", "text": "学习了", "date": "2026-03-21" }
]
}
优点：
缺点：
将数据分散在不同集合，通过ID关联。
场景：
示例：博客文章与评论（评论很多时）
posts集合：
{ "_id": "post_1", "title": "MongoDB入门", "author": "Alice" }
comments集合：
{ "_id": "c1", "postId": "post_1", "user": "Bob", "text": "写得真好" }
{ "_id": "c2", "postId": "post_1", "user": "Charlie", "text": "学习了" }
优点：
缺点：
$lookup聚合），增加延迟。| 考量因素 | 选择嵌入 | 选择引用 |
|---|---|---|
| 关系类型 | 一对一，一对少 | 一对多（多），多对多 |
| 访问模式 | 总是同时读取 | 经常单独读取子数据 |
| 数据增长 | 子数据量有限 | 子数据量无限增长 |
| 一致性 | 需要强一致/原子性 | 可接受最终一致 |
| 写入频率 | 低频 | 高频更新子数据 |
适用于IoT传感器数据、日志、股票行情等。 问题：每秒产生一条记录，一年就是几千万条，索引巨大，查询慢。 方案：将一段时间（如1小时）的数据合并到一个文档的数组中。
{
"_id": "sensor_001_20260320_10", // 传感器ID_日期_小时
"sensorId": "sensor_001",
"startTime": ISODate("2026-03-20T10:00:00Z"),
"readings": [
{ "ts": "10:00:01", "temp": 23.5 },
{ "ts": "10:00:02", "temp": 23.6 },
// ... 3600个读数
]
}
优势：大幅减少文档数量，提高压缩率，范围查询极快。
预计算复杂查询结果并存储。 场景：需要实时显示“每个用户的总消费金额”。 方案：
orders集合存储原始订单。user_stats集合存储预计算结果：{ userId: 1, totalSpent: 5000 }。user_stats。
优势：读取O(1)，无需每次聚合计算。利用MongoDB的灵活Schema，在一个集合中存储不同类型的文档。 场景：内容管理系统，包含文章、视频、图片。
// 都在 contents 集合
{ "type": "article", "title": "...", "body": "..." }
{ "type": "video", "title": "...", "url": "...", "duration": 120 }
查询：db.contents.find({ type: "video" })
优势：简化架构，统一管理。
$lookup。这是性能杀手。如果把数据库比作一本书，索引就是目录。没有目录，你要找一章内容得从头翻到尾（全表扫描）；有了目录，直接翻到页码（索引扫描）。
sort()操作。原则：只为高频查询、排序、唯一性约束的字段创建索引。不要给每个字段都建索引。
最基础的索引。
// 在 email 字段上创建升序索引
db.users.createIndex({ email: 1 })
1表示升序，-1表示降序。对于单键索引，方向不影响查询性能，但为了统一规范，通常用1。在多个字段上建立的索引。顺序至关重要！
// 先按 category 排序，再按 price 排序
db.products.createIndex({ category: 1, price: -1 })
最左前缀原则（Prefix Rule）：
复合索引 { A: 1, B: 1, C: 1 } 可以支持以下查询：
{ A: ... } (){ A: ..., B: ... } (){ A: ..., B: ..., C: ... } (){ B: ... } ( 无法利用索引，因为跳过了A){ A: ..., C: ... } (️ 只能利用A的部分，C无法利用索引排序)技巧：将等值查询的字段放在前面，范围查询（lt）的字段放在后面。
自动为数组字段创建。当你在一个包含数组的字段上创建索引时，MongoDB会为数组中的每个元素创建一个索引条目。
// tags 是数组
db.products.createIndex({ tags: 1 })
强制字段值唯一，类似主键约束。
// 确保用户名不重复
db.users.createIndex({ username: 1 }, { unique: true })
null值也被视为相同。如果允许多个文档没有该字段，需结合partialFilterExpression。只对满足特定条件的文档建立索引。节省空间，提高写入性能。
// 只为未完成的订单建立索引
db.orders.createIndex(
{ status: 1, createdAt: -1 },
{ partialFilterExpression: { status: { $in: ["pending", "processing"] } } }
)
自动过期删除文档。非常适合日志、会话、验证码。
// 文档在 createdAt 字段时间后的24小时自动删除
db.logs.createIndex(
{ createdAt: 1 },
{ expireAfterSeconds: 86400 }
)
支持全文搜索。
// 在 title 和 content 上建立文本索引
db.articles.createIndex({ title: "text", content: "text" })
// 搜索
db.articles.find({ $text: { $search: "MongoDB tutorial" } })
用于近似最近邻搜索（ANN），支持AI语义搜索。
// 假设 embeddings 是 1536 维的向量数组
db.products.createIndex(
{ embedding: "vector" },
{
vectorOptions: {
dimensions: 1536,
similarity: "cosine", // 余弦相似度
type: "hnsw" // 算法类型
}
}
)
$vectorSearch聚合阶段使用。db.products.getIndexes()
// 删除特定索引
db.products.dropIndex("category_1_price_-1")
// 删除除_id外的所有索引
db.products.dropIndexes()
explain()这是调优的神器。
db.products.find({ category: "Electronics", price: { $gt: 100 } })
.explain("executionStats")
关注关键指标：
winningPlan.stage:
IXSCAN: 好，使用了索引扫描。COLLSCAN: 坏，全表扫描。executionStats.totalDocsExamined: 扫描了多少文档。越小越好。executionStats.totalKeysExamined: 扫描了多少索引键。executionStats.executionTimeMillis: 执行耗时。理想状态：totalDocsExamined 接近 nReturned（返回数量）。如果扫描了10000个文档只返回1个，说明索引没建好。
{ category: "A" }, 投影：{ name: 1 }{ category: 1, name: 1 }$indexStats聚合命令查看索引使用次数，删除从未使用的索引。background: true选项（虽然8.0版本优化了很多，但在超大表上仍建议离线或低峰期操作）。
db.bigCollection.createIndex({ field: 1 }, { background: true })
如果说find()是匕首，那么**聚合管道（Aggregation Pipeline）**就是瑞士军刀。它允许你对数据进行复杂的转换、统计、分组和分析。
想象一个工厂流水线。文档进入管道，经过一个个**阶段（Stage）**的处理，每个阶段对文档进行修改、过滤或分组，最后产出结果。
语法：
db.collection.aggregate([
{ $match: { ... } }, // 阶段1：过滤
{ $group: { ... } }, // 阶段2：分组
{ $sort: { ... } }, // 阶段3：排序
{ $limit: { ... } } // 阶段4：限制
])
$match：过滤类似于find()，但用在管道中。务必放在管道最前面，尽早减少数据量。
{ $match: { status: "active", amount: { $gt: 100 } } }
$project：重塑文档选择要输出的字段，重命名字段，或计算新字段。
{
$project: {
name: 1, // 保留name
fullName: { $concat: ["$firstName", " ", "$lastName"] }, // 计算新字段
_id: 0 // 隐藏_id
}
}
$group：分组统计最强大的阶段之一。类似SQL的GROUP BY。
{
$group: {
_id: "$category", // 按类别分组
totalCount: { $sum: 1 }, // 计数
avgPrice: { $avg: "$price" }, // 平均价格
maxStock: { $max: "$stock" } // 最大库存
}
}
_id可以是字段值、表达式或null（全局聚合）。$sort：排序{ $sort: { totalCount: -1 } }
$limit & $skip：分页{ $limit: 10 }
$unwind：展开数组将数组字段拆解成多个文档。 输入：
{ name: "Book", tags: ["A", "B"] }
$unwind: "$tags" 后：
{ name: "Book", tags: "A" }
{ name: "Book", tags: "B" }
$lookup：左连接（Left Join）关联另一个集合。
{
$lookup: {
from: "categories", // 关联的集合名
localField: "categoryId", // 当前集合字段
foreignField: "_id", // 关联集合字段
as: "categoryInfo" // 输出字段名（数组）
}
}
$lookup性能开销较大，尽量在$match过滤后使用，或通过数据建模避免使用。$addFields：添加字段类似于$project，但保留所有原有字段，只添加或修改指定字段。
MongoDB 5.0+引入，8.0增强。用于计算移动平均、累计和等。
{
$setWindowFields: {
partitionBy: "$userId",
sortBy: { date: 1 },
output: {
runningTotal: {
$sum: "$amount",
window: { documents: ["unbounded", "current"] }
}
}
}
}
需求：统计2026年第一季度，每个类别的销售总额，并按总额降序排列，只取前5名。
db.orders.aggregate([
// 1. 过滤时间范围
{
$match: {
orderDate: {
$gte: ISODate("2026-01-01"),
$lt: ISODate("2026-04-01")
},
status: "completed"
}
},
// 2. 展开订单项数组（假设一个订单有多个商品）
{ $unwind: "$items" },
// 3. 计算每项的总价
{
$addFields: {
itemTotal: { $multiply: ["$items.price", "$items.quantity"] }
}
},
// 4. 按类别分组统计
{
$group: {
_id: "$items.category",
totalSales: { $sum: "$itemTotal" },
orderCount: { $sum: 1 }
}
},
// 5. 排序
{ $sort: { totalSales: -1 } },
// 6. 取前5
{ $limit: 5 }
])
$match 越早越好。$project 尽早减少字段。$unwind 和 $group 尽量后置。$match和$sort可以利用集合上的索引。allowDiskUse: true（允许溢出到磁盘，但会变慢）。
db.collection.aggregate(pipeline, { allowDiskUse: true })
而不先$match`是极其危险的。当你的应用长大了，单台服务器扛不住了，怎么办？MongoDB提供了两套解决方案：副本集（高可用）和分片集群（水平扩展）。
副本集是一组维护相同数据集的mongod进程。
如果主节点挂了：
控制一致性和性能的滑块。
w: 1 (默认): 主节点确认即返回。快，但主挂掉可能丢数据。w: "majority": 多数节点确认。安全，推荐生产使用。local: 读最新数据，可能读到回滚数据。majority: 保证读到已持久化到多数节点的数据。linearizable: 最强一致性，读起来像锁住了，慢。决定读请求发给谁。
primary (默认): 只读主节点。保证数据最新。secondary: 只读从节点。分担读压力，但数据可能有延迟。nearest: 读网络延迟最低的节点。当数据量超过单机存储，或写入吞吐量超过单机极限时，需要分片。
分片键决定了数据如何分布。选错分片键，分片集群性能可能不如单机！
好的分片键特征：
userId, email），确保数据均匀分布。createdAt, 自增ID），否则所有新写入都打到最后一个分片（热点）。常见策略：
{ userId: "hashed" }。数据分布最均匀，适合随机读，但不支持范围查询。{ region: 1, createdAt: -1 }。适合范围查询，但要注意写入热点。status），可以组合其他字段。当某个分片数据过多时，集群会自动将数据块（Chunk）迁移到其他分片。
MongoDB 4.0+支持ACID事务，让你在多个文档、甚至多个集合/分片之间保证原子性。
使用场景：
代码示例（Node.js驱动）：
const session = client.startSession();
session.startTransaction();
try {
await accounts.updateOne(
{ _id: "A" },
{ $inc: { balance: -100 } },
{ session }
);
await accounts.updateOne(
{ _id: "B" },
{ $inc: { balance: 100 } },
{ session }
);
await session.commitTransaction();
} catch (error) {
await session.abortTransaction();
throw error;
} finally {
session.endSession();
}
最佳实践：
作为2026年的初学者，你必须了解MongoDB的最新能力，特别是AI方面。
生成式AI的爆发让向量数据库成为刚需。MongoDB 8.0将向量搜索深度集成。
场景：
工作流程：
[0.12, -0.45, ...]）。$vectorSearch。db.products.aggregate([
{
$vectorSearch: {
index: "embedding_index",
path: "embedding",
queryVector: [0.1, 0.2, ...], // 用户问题的向量
numCandidates: 100,
limit: 5
}
},
{
$project: {
name: 1,
score: { $meta: "vectorSearchScore" }
}
}
])
专为IoT、坚控数据设计。
timeField和metaField。
db.createCollection("sensors", {
timeseries: {
timeField: "timestamp",
metaField: "sensorId",
granularity: "seconds"
}
})
集合的变化（增删改），实时触发业务逻辑。
const changeStream = db.orders.watch();
changeStream.on('change', (change) => {
console.log('Order changed:', change);
if (change.operationType === 'insert') {
sendNotification(change.fullDocument);
}
});
新手最容易忽视安全，导致数据泄露或被勒索。
use admin
db.createUser({
user: "admin",
pwd: "strong_password",
roles: ["root"]
})
readWrite权限，且仅限特定数据库。你需要坚控什么？
工具：
mongodb_exporter。备份策略：
mongodump --uri="mongodb://..." --out=/backup/path
恢复演练：定期（每季度）尝试从备份恢复数据，确保备份有效。
explain()分析并优化。祝你在MongoDB的学习之路上顺利前行，成为一名优秀的后端工程师！世界的数据等待你去驾驭。
