MongoDB on Snow

Databases Panorama:From SQLite to MongoDB, A Complete Guide

Tue, 07 Jul 2026 21:04:00 +0800

数据库全景指南：从 SQLite 到 MongoDB，一文搞懂选型与差异

MySQL、PostgreSQL、MongoDB、Redis、Cassandra、Neo4j、Elasticsearch…… 数据库多到让人眼花。本文从分类、原理、模型、选型、组合五个维度，带你看清它们各自的边界与适用场景。

一、为什么会有这么多数据库？

先抛一个真实的尴尬场景：

新人入职第一天，被安排设计一个博客系统。他下意识打开 Navicat，建了一张 articles 表，写到第三天发现：文章正文要存富文本，字数可能上万；评论数据要嵌套在文章里；标签数量不固定；还要做全文搜索。继续用 MySQL 越写越别扭，最后只能上 ES 做搜索、MongoDB 存正文、MySQL 存元数据。

这不是个例。没有一种数据库能赢下所有场景，根本原因是存储需求里同时存在四组矛盾：

结构化 vs 灵活：业务模型固定还是多变
一致性 vs 可用性：要数据绝对正确，还是允许短暂数据不一致换可用性
规模 vs 性能：单机极致性能还是分布式海量吞吐
读写均衡 vs 海量写入：典型 Web 应用还是 IoT 流式写入

围绕这些矛盾，业界演化出了关系型、键值、文档、列族、图、搜索、时序、列存分析等 八大分支。每解决一组矛盾，就诞生一类新数据库。

二、数据库分类全景图

上图把主流数据库按"数据模型 + 适用场景"分成了 8 类。下面我们逐类展开，但在分类之前，必须先理解三个底层概念：ACID、CAP、BASE。它们决定了数据库的"性格"。

三、ACID vs BASE：两种一致性哲学

ACID：关系型数据库的承诺

ACID 是事务的四大保证，是关系型数据库压箱底的能力：

字母	含义	通俗解释
A Atomicity 原子性	事务要么全成功，要么全回滚	转账扣款和加款必须同时发生
C Consistency 一致性	事务前后满足所有约束	主键、外键、CHECK 不能被破坏
I Isolation 隔离性	并发事务互不干扰	MVCC + 锁机制保证
D Durability 持久性	提交后即使宕机也不丢	通过 WAL / redo log 实现

为 ACID 付出的代价：锁竞争、跨节点协调延迟、水平扩展难。这也是为什么单机 MySQL 通常撑到几千 QPS 就开始考虑读写分离。

BASE：分布式系统的妥协

当系统走向分布式，强一致性的代价过高，业界提出 BASE 作为 AP 系统的设计哲学：

BA Basically Available 基本可用：允许响应变慢、允许功能降级
S Soft State 软状态：允许存在中间状态
E Eventually Consistent 最终一致：不保证任意时刻一致，但保证最终收敛

关键认知：ACID 中的 C 是事务一致性（约束不被破坏），CAP 中的 C 是副本一致性（多节点数据相同），两者不是一回事。

四、CAP 定理：分布式系统的三角抉择

CAP 定理由 Eric Brewer 在 2000 年提出，断言：一个分布式系统最多只能同时满足 Consistency（一致性）、Availability（可用性）、Partition tolerance（分区容错）三者中的两个。

三个关键认知

① P 不可避免

真实分布式系统必然存在网络分区（交换机抖动、机房断连、节点宕机）。所以工程师实际上只能在 C 和 A 之间做选择：

分区时拒绝写入 → CP，保证数据正确，但牺牲可用性
分区时仍可读写 → AP，保证可用性，但允许数据短暂不一致

② 三种组合的典型代表

组合	牺牲项	典型数据库	典型场景
CA	分区容错	MySQL 单机、PostgreSQL 单机	传统单机业务
CP	可用性	HBase、MongoDB、Redis 集群	强一致优先的金融、配置
AP	一致性	Cassandra、DynamoDB、Eureka	高可用的社交、推荐

③ 同一业务可灵活切换

注册中心是个经典例子：ZooKeeper 是 CP，选举期间不可用；Eureka 是 AP，节点之间不强制同步。Netflix 选 Eureka，因为它能容忍注册信息短暂不一致，但不能容忍服务发现挂掉。

五、关系型数据库：稳如泰山的基石

关系型数据库以 二维表 + SQL + ACID 事务 为核心，是 90% 业务系统的默认选择。

5.1 五大主流 RDBMS 对比

数据库	厂商 / 协议	强项	适用场景
MySQL	开源（GPL/商业双协议）	生态成熟、运维资料最多	Web 应用、电商、CMS
PostgreSQL	开源（BSD）	复杂查询、JSON、PostGIS、扩展性强	复杂业务、地理数据、数据分析
SQLite	开源（公有领域）	嵌入式、零配置、单文件	移动端、嵌入式、原型、测试
Oracle	商业	企业级功能、稳定性、技术支持	银行、电信、政府核心系统
SQL Server	商业（微软）	与 .NET 生态深度集成	企业内部系统、Windows 环境

5.2 选型经验

个人项目 / 小工具：SQLite，单文件零配置
Web 应用首选：MySQL（运维生态好）或 PostgreSQL（功能强、复杂查询爽）
企业核心系统有预算：Oracle 或 SQL Server，看团队技术栈
要不要选 PostgreSQL 而不是 MySQL？ 如果业务里有复杂分析、地理数据、强约束、JSON 字段，PG 更合适；如果只是 CRUD + 简单关联，MySQL 更省心

5.3 关系型的硬伤

水平扩展难：分库分表后跨库 JOIN、事务都成噩梦，需要引入 ShardingSphere、Vitess 之类的中间件
Schema 变更贵：上亿行表加索引可能锁表几小时
高并发写入瓶颈：单机通常几千 QPS，靠缓存兜底

六、NoSQL 的崛起：四大家族

NoSQL（Not Only SQL）的核心动机：通过放松某个约束（一致性 / Schema / 关系），换取扩展性、性能或灵活性。

6.1 SQL vs NoSQL 数据模型对比

左图是关系型的方式：范式化拆表 + 外键关联，查 Alice 的订单要 JOIN 两张表。右图是文档型的方式：聚合存储 + 内嵌文档，Alice 的订单直接嵌在她的文档里，一次读取拿全。

两种模型各有利弊：

维度	关系型（SQL）	文档型（NoSQL）
Schema	严格固定	灵活可变
关联查询	JOIN 强	弱（要靠应用层）
数据冗余	低（范式化）	高（反范式）
事务	强 ACID	弱（多文档 4.0+ 才支持）
扩展性	垂直为主	易水平分片
适合	关系复杂、强一致	模型多变、读多写少

6.2 键值型：Redis

Redis 是最被低估的"瑞士军刀"。它表面上是个缓存，实际上能做：

缓存：最常见，热点数据加速
会话存储：分布式 Session
排行榜：ZSet 天生支持
消息队列：List / Stream
限流器：INCR + EXPIRE
分布式锁：SETNX / Redlock

选型提醒：Redis 是 CP 系统（集群模式下）—— 主节点挂掉会触发故障转移，期间集群不可用。不是所有 Redis 都"高可用"。

6.3 文档型：MongoDB

MongoDB 用 BSON（二进制 JSON）存储，每个文档自包含。它的甜点场景：

内容管理：文章、评论、附件，结构天然嵌套
IoT 设备元数据：不同设备字段不同，灵活 Schema 太香
快速迭代业务：需求变就加字段，不用 ALTER TABLE
日志聚合：MongoDB 的聚合管道 + 副本集很合用

坑点：MongoDB 4.0 才支持多文档事务，复杂事务场景慎用。索引设计不当会让查询慢到怀疑人生。

6.4 列族型：Cassandra / HBase

列族型数据库把"行"打散成"列族"，同一列的数据连续存储，对"按列聚合 + 海量写入"特别友好。

Cassandra：AWS Dynamo 论文的开源实现，无主架构，写入性能极强。Netflix、Instagram、Apple 都在用
HBase：基于 HDFS，强一致，适合离线大数据
ScyllaDB：用 C++ 重写的 Cassandra，性能高一个数量级

典型场景：时序数据、推荐特征存储、消息历史归档。Cassandra 在写入 QPS 上能轻松甩开 MySQL 一个数量级。

6.5 图型：Neo4j

如果业务核心是关系（不是表关联，而是多跳关系遍历），用图数据库比 SQL 递归查询快几个数量级。

// Neo4j 查询：找到 Alice 三度人脉里喜欢 Go 语言的人
MATCH (a:User {name:'Alice'})-[:KNOWS*1..3]-(friend:User)
WHERE friend.language = 'Go'
RETURN friend

典型场景：社交网络（好友推荐）、反欺诈（团伙识别）、知识图谱、IT 资产拓扑。

用 MySQL 写"找三度人脉"要用 4 层自连接，性能爆炸；Neo4j 用邻接表存储，时间复杂度近似 O(1)。

七、专用场景数据库：搜索 / 时序 / 列存

通用数据库做不到极致，专用数据库在特定领域把性能压榨到极限。

7.1 搜索引擎：Elasticsearch

ES 用 倒排索引 实现秒级全文检索，是 ELK（Elasticsearch + Logstash + Kibana）的核心。

商品搜索：分词、同义词、纠错、相关性排序
日志分析：海量日志聚合，按时间维度切片
可观测性：APM、链路追踪数据存储

重要认知：ES 不是数据库替代品。它写入延迟较高（近实时，1 秒刷新），不适合做强一致主存储。通常 MySQL 是真相源，ES 是搜索副本，通过 Canal/Debezium 同步。

7.2 时序数据库：InfluxDB / TimescaleDB

时序数据有显著特征：写多读少、按时间顺序、自动降采样、旧数据可丢弃。专用 TSDB 的写入性能比 MySQL 高 1-2 个数量级。

InfluxDB：Go 写的，单机性能强，TSM 存储引擎
TimescaleDB：PostgreSQL 扩展，能用 SQL，事务保证更好
Prometheus：监控专用，pull 模型
TDengine：国产，物联网场景优化

典型场景：服务器监控、IoT 传感器、金融行情、用户行为埋点。

7.3 列存分析：ClickHouse

OLAP 场景的核心诉求：扫描 TB 级数据，做 GROUP BY 聚合，秒级返回。行存数据库（MySQL）做这种扫描会读大量无关列，列存数据库只读需要的列，性能差几十倍。

-- ClickHouse 典型查询：秒级扫描 10 亿行
SELECT
    toDate(event_time) AS day,
    city,
    count() AS pv,
    uniq(user_id) AS uv
FROM events
WHERE event_time >= today() - 30
GROUP BY day, city
ORDER BY day DESC, pv DESC

对比：同样的查询，MySQL 要几十分钟，ClickHouse 通常 1 秒内。

八、数据库选型决策树

讲了这么多，实战怎么选？下图给出一份决策路径：

三条选型铁律

① 先 SQL，后 NoSQL

绝大多数项目从 MySQL / PostgreSQL 起步就够了。遇到具体瓶颈（缓存、搜索、海量写入、复杂关系）再引入对应专用数据库。一开始就上"全家桶"是过度设计。

② 没有银弹，组合使用

工业界真实系统几乎都是多库组合：核心业务用 MySQL/PG，缓存用 Redis，搜索用 ES，日志用 MongoDB/ES，监控用 InfluxDB，分析用 ClickHouse。让每个数据库只做它最擅长的事。

③ 团队熟悉度优先

再先进的数据库，没人会运维也是灾难。Cassandra 写入性能强，但运维门槛极高，国内很多团队踩坑后还是换回了 MySQL 分库分表。选团队能掌控的，而不是最潮的。

九、真实项目中的数据库组合架构

光说不练假把式。下图是一个典型电商系统的多库协同架构：

数据流拆解

① 写路径：订单服务先写 MySQL（强一致保证），同时发 Kafka 事件，下游消费者异步更新 ES 搜索索引和推荐系统特征库。这是经典的 “先写主库，再异步同步” 模式。

② 读路径：

请求类型	走的数据库	理由
商品详情	Redis 缓存 → MongoDB	缓存挡 95% 流量，回源用文档库装多变 SKU
商品搜索	Elasticsearch	倒排索引秒级响应
好友推荐	Neo4j	多跳关系遍历
个人订单	MySQL	强一致，按用户分库
监控大盘	InfluxDB	时序聚合，秒级出图

③ 监控旁路：所有服务通过 SDK 把指标推送到 InfluxDB，不参与业务主链路，监控挂掉不影响交易。这是旁路系统的设计铁律。

为什么要拆？

如果不拆，全塞进 MySQL 会发生什么？

商品搜索做 LIKE ‘%关键词%’ → 全表扫描，慢到超时
监控指标每秒几十万条写入 → MySQL 单机扛不住
好友推荐用 4 层自连接 → 几秒出不来结果
商品 SKU 字段每类目都不同 → ALTER TABLE 改到吐血

每个专用数据库的存在，都是为了 解决某一类 MySQL 不擅长的问题。

十、核心差异对照表

最后用一张表把主流数据库的关键指标摊开对比：

数据库	类型	一致性	Schema	事务	水平扩展	典型 QPS	适合场景
MySQL	关系	ACID	严格	强	难（需中间件）	几千	Web 主流
PostgreSQL	关系	ACID	严格	强	难	几千	复杂业务
SQLite	关系	ACID	严格	强	不可	单线程	嵌入式
Redis	KV	CP	无	弱	集群分片	10万+	缓存
MongoDB	文档	CP（可调）	灵活	4.0+ 多文档	易分片	几万	内容管理
Cassandra	列族	AP（可调）	灵活	弱	极易	10万+ 写入	海量写入
Neo4j	图	ACID	半结构	强	难	几千	关系网络
Elasticsearch	搜索	近实时	动态映射	弱	易分片	几万	全文搜索
InfluxDB	时序	CP	标签+字段	弱	集群版收费	10万+ 写入	监控指标
ClickHouse	列存	CP	严格	弱	易分片	100万+ 写入	大数据分析

总结

回到最初的问题：SQLite、MySQL、MongoDB 有什么区别？ 它们不是"谁更好"的关系，而是"为不同问题而生"的不同工具。

回顾本文核心要点：

没有银弹：每种数据库都是某组矛盾的产物，关系型解决一致性、NoSQL 解决扩展性、专用库解决极端场景
理论先行：理解 ACID / BASE / CAP，是看懂所有数据库设计意图的钥匙
SQL 不死：关系型依然是 90% 业务系统的默认选择，NoSQL 是补充而非替代
组合才是常态：工业界真实系统几乎都是多库协同，让每个数据库只做它最擅长的事
选型三铁律：先 SQL 后 NoSQL、没有银弹要组合、团队熟悉度优先

下一步行动建议：

审视你当前的项目：是不是把所有数据都塞在 MySQL 里了？哪些场景其实更适合专用数据库？
挑一个不熟的数据库试一试：Redis / MongoDB / ES 任选一个，跑一遍官方 Quick Start
关注 NewSQL：TiDB、CockroachDB、YugabyteDB 这些"既有 ACID 又能水平扩展"的下一代数据库正在崛起

记住：好的架构师不在于会多少种数据库，而在于知道每种数据库的边界在哪。

本文涉及的所有数据库选型都基于公开文档与工程实践，具体落地还需结合团队技术栈、运维能力、预算综合判断。

MongoDB Tutorial

Thu, 23 Apr 2026 21:49:15 +0800

前言

MongoDB 作为当前最流行的文档型 NoSQL 数据库，凭借其灵活的文档模型、强大的扩展能力和卓越的性能，已经成为现代互联网应用架构中不可或缺的一环。无论是初创公司的快速迭代，还是巨头企业的海量数据存储，MongoDB 都展现出了极强的适应性。

本指南旨在为你提供一份从零基础到生产实战的完整学习路径。我们将从最基础的概念讲起，逐步深入到高级查询、索引优化、分布式架构，最后结合 Python 实战，帮助你彻底打通 MongoDB 的任督二脉。

无论你是刚入门的后端开发新手，还是希望深入优化数据库性能的资深工程师，这份指南都能为你提供详实的参考。

第一章：MongoDB 核心认知

1.1 什么是 MongoDB？

MongoDB 是一个开源、跨平台、面向文档的非关系型数据库。它将数据存储为一个文档，数据结构由键值对组成，类似于 JSON 对象，但采用二进制的 BSON 格式进行存储和传输，这使得它能够支持更丰富的数据类型和更快的解析速度。

核心特性：

灵活的文档模型：无需预定义 Schema，字段可以动态添加，完美适配需求快速变化的业务。
强大的索引支持：支持单字段、复合、地理空间、全文等多种索引类型。
高可用：通过副本集（Replica Set）实现数据自动备份和故障转移。
水平扩展：通过分片（Sharding）技术，将数据分散到多台机器，轻松应对 PB 级数据。
丰富的查询语言：支持聚合、事务、Graph 查询等复杂操作。

1.2 核心概念与术语

对于从关系型数据库（如 MySQL）转过来的开发者，理解下面的对应关系至关重要：

MongoDB 术语	MySQL 术语	说明
Database (数据库)	Database (数据库)	数据的物理容器，一个 MongoDB 实例可以包含多个 Database
Collection (集合)	Table (表)	一组文档的集合，类似于关系型数据库中的表
Document (文档)	Row (行)	一条记录，以 BSON 格式存储，类似于 JSON 对象
Field (字段)	Column (列)	文档中的一个属性，类似于表中的列
Index (索引)	Index (索引)	加速查询的数据结构
Primary Key (主键)	Primary Key (主键)	MongoDB 自动提供 `_id` 字段作为主键

1.3 BSON 数据类型

MongoDB 使用 BSON（Binary JSON）来存储数据，它比 JSON 支持更多的数据类型：

String：字符串，必须是 UTF-8 编码。
Integer：整型，32 位或 64 位，取决于环境。
Boolean：布尔值，true 或 false。
Double：双精度浮点型。
ObjectId：12 字节的唯一 ID，用于文档的唯一标识。
Array：数组，列表或有序集合。
Object：嵌套文档。
Date：日期时间，存储为从 Unix 纪元开始的毫秒数。
Binary：二进制数据，用于存储二进制流。
Code：JavaScript 代码。

_id 解析：默认的 _id 字段是一个 ObjectId，它不是随机的，而是包含了时间戳、机器码、进程 ID 和自增计数器，因此你可以直接从中提取创建时间：ObjectId("507f1f77bcf86cd799439011").getTimestamp()

1.4 MongoDB vs MySQL：该如何选择？

很多人会问，MongoDB 和 MySQL 到底哪个好？其实没有绝对的好坏，只有适合不适合。

MongoDB 更适合：

数据结构频繁变化：电商商品属性、用户画像、内容管理系统。
海量数据读写：日志系统、物联网设备数据、用户行为埋点。
高并发读写：社交网络的 Feed 流、实时数据统计。
地理位置查询：LBS 服务、附近的人 / 商家。
快速开发迭代：初创项目，需求频繁变动。

MySQL 更适合：

强事务性系统：金融交易、订单支付、库存扣减。
复杂的多表关联查询：传统的 ERP、CRM 系统。
严格的结构化数据：报表系统、财务系统。

第二章：环境搭建与部署

MongoDB 支持全平台部署，下面我们介绍几种最常用的安装方式。

2.1 Docker 一键部署（推荐开发环境）

对于开发和测试环境，使用 Docker 是最快的方式，一行命令即可启动。

# 拉取镜像并启动
docker run -d \
  --name mongodb \
  -p 27017:27017 \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=your_strong_password \
  mongo:7.0

如果你需要持久化数据，可以挂载数据卷：

docker volume create mongo_data
docker run -d \
  --name mongodb \
  -p 27017:27017 \
  -v mongo_data:/data/db \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=your_strong_password \
  mongo:7.0

2.2 Linux 系统安装（生产环境推荐）

以 Ubuntu 20.04/22.04 为例：

# 1. 导入公钥
wget -qO - https://www.mongodb.org/static/pgp/server-7.0.asc | sudo apt-key add -

# 2. 添加源
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

# 3. 安装
sudo apt-get update
sudo apt-get install -y mongodb-org

# 4. 启动服务
sudo systemctl start mongod
sudo systemctl enable mongod

# 5. 验证
sudo systemctl status mongod

2.3 Windows 系统安装

前往 MongoDB 下载中心下载 MSI 安装包。
运行安装程序，选择 “Complete” 安装。
安装向导会自动将 MongoDB 安装为 Windows 服务。
安装完成后，在命令行输入 mongo 即可连接。

2.4 连接数据库

安装完成后，使用 mongosh（新版的 MongoDB Shell）连接数据库：

# 本地无认证连接
mongosh

# 带账号密码连接
mongosh "mongodb://admin:your_strong_password@localhost:27017/?authSource=admin"

第三章：基础操作：CRUD 增删改查

掌握了连接之后，我们来学习最基础的增删改查操作。所有的操作都围绕着集合（Collection）进行。

3.1 数据库与集合管理

// 查看所有数据库
show dbs

// 切换/创建数据库（插入数据后才会真正创建）
use test_db

// 查看当前数据库
db

// 查看当前数据库下的集合
show collections

// 创建集合（可选，插入数据时自动创建）
db.createCollection("users")

// 删除集合
db.users.drop()

// 删除当前数据库
db.dropDatabase()

3.2 插入文档（Create）

MongoDB 提供了 insertOne 和 insertMany 两个方法。

插入单个文档

db.users.insertOne({
  name: "张三",
  age: 25,
  email: "zhangsan@example.com",
  hobbies: ["篮球", "游戏"],
  address: {
    province: "广东",
    city: "深圳"
  },
  createTime: new Date()
})

返回结果会包含自动生成的 _id：

{
  "acknowledged" : true,
  "insertedId" : ObjectId("662f...")
}

插入多个文档

db.users.insertMany([
  { name: "李四", age: 28, gender: "female" },
  { name: "王五", age: 30, gender: "male" },
  { name: "赵六", age: 26, gender: "female" }
])

3.3 查询文档（Read）

查询是 MongoDB 最强大的部分之一。

基础查询

// 查询所有文档
db.users.find()

// 查询单个文档（返回第一条匹配的）
db.users.findOne({ name: "张三" })

// 条件查询
db.users.find({ age: 25 }) // age 等于 25
db.users.find({ age: { $gt: 25 } }) // age 大于 25
db.users.find({ age: { $gte: 25, $lt: 30 } }) // 25 <= age < 30
db.users.find({ name: { $ne: "张三" } }) // name 不等于 张三

常用查询运算符

运算符	作用	示例
`$gt`	大于	`{ age: { $gt: 25 } }`
`$gte`	大于等于	`{ age: { $gte: 25 } }`
`$lt`	小于	`{ age: { $lt: 30 } }`
`$lte`	小于等于	`{ age: { $lte: 30 } }`
`$ne`	不等于	`{ age: { $ne: 25 } }`
`$in`	包含在数组中	`{ age: { $in: [25, 30] } }`
`$nin`	不包含在数组中	`{ age: { $nin: [25, 30] } }`
`$and`	逻辑与	`$and: [ {age: 25}, {name: "张三"} ]`
`$or`	逻辑或	`$or: [ {age: 25}, {name: "张三"} ]`

数组查询

// 包含某个元素
db.users.find({ hobbies: "篮球" })

// 包含所有指定元素
db.users.find({ hobbies: { $all: ["篮球", "游戏"] } })

// 数组长度
db.users.find({ hobbies: { $size: 2 } })

嵌套文档查询

// 精确匹配整个嵌套文档
db.users.find({ address: { province: "广东", city: "深圳" } })

// 点表示法，匹配单个字段（推荐）
db.users.find({ "address.city": "深圳" })

分页、排序、投影

// 排序：1 升序，-1 降序
db.users.find().sort({ age: -1 }) // 按年龄倒序

// 分页：skip 跳过，limit 限制
db.users.find().skip(10).limit(10) // 第2页，每页10条

// 投影：只返回指定字段，1 显示，0 隐藏
db.users.find({}, { name: 1, age: 1, _id: 0 })

3.4 更新文档（Update）

更新操作需要使用更新操作符，否则会直接替换整个文档。

更新单个文档

// $set：只更新指定字段，推荐！
db.users.updateOne(
  { name: "张三" }, // 条件
  { $set: { age: 26, email: "new_email@example.com" } } // 更新内容
)

更新多个文档

// 给所有年龄小于18岁的用户添加一个字段
db.users.updateMany(
  { age: { $lt: 18 } },
  { $set: { isMinor: true } }
)

常用更新运算符

// $inc：字段自增
db.users.updateOne({ name: "张三" }, { $inc: { age: 1 } }) // 年龄+1

// $push：向数组添加元素
db.users.updateOne({ name: "张三" }, { $push: { hobbies: "游泳" } })

// $addToSet：向数组添加元素，不存在才添加（去重）
db.users.updateOne({ name: "张三" }, { $addToSet: { hobbies: "游泳" } })

// $pull：从数组删除元素
db.users.updateOne({ name: "张三" }, { $pull: { hobbies: "游戏" } })

// $unset：删除字段
db.users.updateOne({ name: "张三" }, { $unset: { isMinor: 1 } })

Upsert 操作

如果找不到匹配的文档，就插入一个新的：

db.users.updateOne(
  { name: "钱七" },
  { $set: { age: 27 } },
  { upsert: true } // 开启 upsert
)

3.5 删除文档（Delete）

// 删除单个文档
db.users.deleteOne({ name: "赵六" })

// 删除多个文档
db.users.deleteMany({ age: { $lt: 18 } })

// 删除所有文档（保留集合）
db.users.deleteMany({})

⚠️ 警告：执行 deleteMany({}) 会清空整个集合，且无法回滚！生产环境操作前务必确认条件！

第四章：索引与性能优化

索引是数据库性能的关键。合理的索引可以将查询速度从秒级提升到毫秒级。

4.1 索引基础

MongoDB 的索引使用 B 树数据结构，与 MySQL 类似。默认情况下，所有集合都会在 _id 字段上创建一个唯一索引。

创建索引

// 单字段索引：1 升序，-1 降序
db.users.createIndex({ age: 1 })

// 复合索引：多个字段组合
db.orders.createIndex({ status: 1, createdAt: -1 })

// 唯一索引：确保字段值不重复
db.users.createIndex({ email: 1 }, { unique: true })

索引管理

// 查看集合的所有索引
db.users.getIndexes()

// 查看索引大小
db.users.totalIndexSize()

// 删除索引
db.users.dropIndex("age_1")

4.2 复合索引与 ESR 原则

创建复合索引时，字段的顺序至关重要。业界有一个著名的 ESR 原则：

Equality（等值匹配） -> Sort（排序） -> Range（范围查询）

为什么？

等值字段：用来快速定位到具体的行，应该放在最前面。
排序字段：让数据库在取出数据后不需要再内存排序，可以直接按索引顺序返回。
范围字段：放在最后，因为范围查询会导致后面的字段索引失效。

示例： 查询：status = "completed" AND amount > 100 ORDER BY createdAt DESC

错误的索引：{status: 1, amount: 1, createdAt: -1} 正确的索引：{status: 1, createdAt: -1, amount: 1}

4.3 高级索引类型

1. 部分索引（Partial Index）

只对符合条件的文档建立索引，大大减小索引体积。

// 只对已支付的订单建立索引，草稿订单不索引
db.orders.createIndex(
  { userId: 1, createdAt: -1 },
  { partialFilterExpression: { status: { $ne: "draft" } } }
)

2. 稀疏索引（Sparse Index）

只对包含特定字段的文档建立索引，适合字段可选的情况。

1
2

// 很多用户没有手机号，只对有手机号的用户建立索引
db.users.createIndex({ phone: 1 }, { sparse: true })

3. 覆盖索引（Covering Index）

如果查询的所有字段都在索引中，数据库就不需要去磁盘读取文档，直接返回索引数据，速度极快。

// 索引包含查询条件和返回字段
db.orders.createIndex({ status: 1, userId: 1, total: 1 })

// 查询只返回这几个字段，就是覆盖查询
db.orders.find({ status: "completed", userId: 123 }, { status: 1, userId: 1, total: 1, _id: 0 })

4.4 索引失效场景

即使建了索引，某些写法也会导致索引失效，触发全表扫描：

使用函数或表达式：db.users.find({ $where: "this.age + 10 > 30" })
正则非前缀匹配：db.users.find({ name: /zhang/ })（应该用 /^zhang/）
不满足最左前缀：复合索引 {a:1, b:1}，只查 b 会失效。
**使用 **$ne 或 $not：有时候会导致索引失效。
数据类型不匹配：字段是 Number，你传了 String。

4.5 慢查询分析

如何找到慢查询？MongoDB 内置了分析工具。

// 开启慢查询日志，记录所有超过 100ms 的操作
db.setProfilingLevel(1, { slowms: 100 })

// 查看最近的慢查询
db.system.profile.find().sort({ ts: -1 }).limit(10)

// 查看执行计划，分析查询是否走了索引
db.users.find({ age: { $gt: 25 } }).explain("executionStats")

重点看 explain 的结果：

stage: "IXSCAN"：索引扫描，正常。
stage: "COLLSCAN"：全集合扫描，有问题！
executionTimeMillis：执行时间。
totalDocsExamined：扫描的文档数，如果远大于 nReturned，说明索引没建好。

第五章：高级查询特性

除了基础的 CRUD，MongoDB 还有很多强大的高级特性。

5.1 地理空间查询（LBS）

MongoDB 原生支持地理位置查询，完美适配外卖、网约车、同城社交等场景。

1. 存储格式

地理数据使用 GeoJSON 格式：

{
  name: "肯德基",
  location: {
    type: "Point",
    coordinates: [113.327, 23.125] // 注意：先经度，后纬度！
  }
}

2. 创建地理索引

`1`	`db.merchants.createIndex({ location: "2dsphere" })`

3. 查询附近的商家

// 查询我当前位置(113.330, 23.127)附近3公里内的商家
db.merchants.find({
  location: {
    $near: {
      $geometry: {
        type: "Point",
        coordinates: [113.330, 23.127]
      },
      $maxDistance: 3000 // 单位：米
    }
  }
})

4. 查询某个区域内的商家

// 查询某个多边形商圈内的商家
db.merchants.find({
  location: {
    $geoWithin: {
      $geometry: {
        type: "Polygon",
        coordinates: [[
          [113.320, 23.120],
          [113.340, 23.120],
          [113.340, 23.140],
          [113.320, 23.140],
          [113.320, 23.120]
        ]]
      }
    }
  }
})

5.2 全文检索

MongoDB 内置了全文索引，可以实现轻量级的搜索功能，无需额外部署 Elasticsearch。

// 创建全文索引，支持多个字段
db.goods.createIndex({ name: "text", description: "text", tags: "text" })

// 搜索包含 "苹果" 或 "华为" 的商品
db.goods.find(
  { $text: { $search: "苹果 华为" } },
  { score: { $meta: "textScore" } } // 返回相关性分数
).sort({ score: { $meta: "textScore" } }) // 按相关性排序

5.3 游标操作

当查询结果很大时，MongoDB 使用游标来分批返回数据，避免一次性加载所有数据到内存。

let cursor = db.users.find()

// 手动遍历
while (cursor.hasNext()) {
  printjson(cursor.next())
}

// 设置批量大小
cursor.batchSize(100)

第六章：聚合框架

聚合框架（Aggregation Framework）是 MongoDB 用于数据分析和统计的利器，它类似于 SQL 中的 GROUP BY、JOIN，但更强大。

聚合框架采用 ** 管道（Pipeline）** 模式：数据像流水线一样，依次通过多个阶段（Stage）进行处理。

6.1 常用管道阶段

阶段	SQL 等价操作	作用
`$match`	WHERE	过滤数据
`$group`	GROUP BY	分组统计
`$sort`	ORDER BY	排序
`$limit` / `$skip`	LIMIT / OFFSET	分页
`$project`	SELECT	投影，修改字段
`$lookup`	LEFT JOIN	关联查询
`$unwind`	-	拆分数组
`$facet`	-	多维度统计

6.2 分组统计示例

场景：统计每个省份的用户数量，以及平均年龄。

db.users.aggregate([
  {
    $group: {
      _id: "$address.province", // 按省份分组
      count: { $sum: 1 }, // 计数
      avgAge: { $avg: "$age" }, // 平均年龄
      maxAge: { $max: "$age" }, // 最大年龄
      names: { $push: "$name" } // 收集所有名字
    }
  }
])

6.3 关联查询（$lookup）

MongoDB 3.2+ 支持关联查询，实现了类似 SQL 的 Join 功能。

场景：查询订单，同时关联查询出订单对应的用户信息。

db.orders.aggregate([
  {
    $lookup: {
      from: "users", // 关联的集合
      localField: "userId", // 本集合的关联字段
      foreignField: "_id", // 关联集合的关联字段
      as: "userInfo" // 输出的字段名
    }
  },
  // 因为 lookup 返回的是数组，我们用 $arrayElemAt 取出第一个元素
  {
    $addFields: {
      userInfo: { $arrayElemAt: ["$userInfo", 0] }
    }
  }
])

$facet 允许你在一次查询中，对同一输入数据执行多个聚合管道，非常适合实现报表的多维度统计。

db.orders.aggregate([
  {
    $facet: {
      // 维度1：按状态分类统计
      byStatus: [
        { $group: { _id: "$status", count: { $sum: 1 } } }
      ],
      // 维度2：按月统计销售额
      byMonth: [
        { $group: { _id: { $month: "$createTime" }, total: { $sum: "$amount" } } }
      ],
      // 维度3：Top10 用户
      topUsers: [
        { $group: { _id: "$userId", total: { $sum: "$amount" } } },
        { $sort: { total: -1 } },
        { $limit: 10 }
      ]
    }
  }
])

第七章：事务

从 MongoDB 4.0 开始，MongoDB 支持了多文档事务，保证 ACID 特性。

7.1 事务的使用

// 开启会话
const session = db.getMongo().startSession()
session.startTransaction()

try {
  // 在事务中执行操作
  const users = session.getDatabase("test").users
  const accounts = session.getDatabase("test").accounts
  
  // 操作1：扣减余额
  accounts.updateOne(
    { userId: ObjectId("...") },
    { $inc: { balance: -100 } },
    { session }
  )
  
  // 操作2：增加积分
  users.updateOne(
    { _id: ObjectId("...") },
    { $inc: { points: 100 } },
    { session }
  )
  
  // 提交事务
  session.commitTransaction()
} catch (e) {
  // 出错回滚
  session.abortTransaction()
  throw e
} finally {
  session.endSession()
}

7.2 注意事项

MongoDB 的事务有16MB的大小限制。
事务会带来一定的性能开销，不要滥用。
分片集群的事务需要 MongoDB 4.2+ 支持。

第八章：高可用与分布式架构

当你的业务越来越大，单机已经无法满足需求时，就需要用到 MongoDB 的分布式架构。

8.1 副本集（Replica Set）：高可用

副本集是一组 MongoDB 服务器，它们维护着相同的数据副本。它的作用是：

数据备份：防止单点故障导致数据丢失。
故障转移：主节点挂了，自动从从节点选举一个新的主节点，服务不中断。
读写分离：读请求可以分到从节点，减轻主节点压力。

架构：

Primary（主节点）：处理所有写请求。
Secondary（从节点）：异步复制主节点的数据，可以处理读请求。
Arbiter（仲裁节点）：不存数据，只参与选举，节省资源。

8.2 分片集群（Sharding）：水平扩展

当数据量太大，单台机器存不下，或者读写 QPS 太高，单机扛不住时，就需要分片。

分片就是把一个大集合的数据，切分成小块，分散到不同的机器（Shard）上存储。

分片集群的三大组件：

Shard（分片）：存储实际的数据，每个 Shard 本身就是一个副本集，保证高可用。
Config Server（配置服务器）：存储集群的元数据，比如数据存在哪个分片上。它也必须是副本集。
Mongos（路由）：客户端的入口。它负责把客户端的请求路由到正确的 Shard 上，对客户端透明。

分片键（Shard Key）：分片的核心是选择分片键，它决定了数据如何分布。

必须是一个存在的字段，MongoDB 用它来拆分数据。
好的分片键应该满足：高基数（取值多）、低写入热点（写入均匀分布）。
常见的分片键：用户 ID、时间范围等。

第九章：Python 实战：PyMongo

讲了这么多 Shell 命令，我们来看看在实际的 Python 开发中如何使用 MongoDB。

9.1 安装与连接

`1`	`pip install pymongo`

from pymongo import MongoClient
from pymongo.errors import ConnectionFailure, OperationFailure

# 连接数据库
client = MongoClient(
    "mongodb://admin:your_strong_password@localhost:27017/?authSource=admin",
    maxPoolSize=50,  # 连接池最大连接数
    minPoolSize=5    # 最小空闲连接
)

# 测试连接
try:
    client.admin.command('ping')
    print("连接成功！")
except ConnectionFailure:
    print("服务器不可达")

9.2 增删改查

# 获取数据库和集合
db = client["test_db"]
users_col = db["users"]

# 1. 插入
result = users_col.insert_one({
    "name": "张三",
    "age": 25,
    "hobbies": ["篮球", "游戏"]
})
print("插入ID:", result.inserted_id)

# 2. 查询
user = users_col.find_one({"name": "张三"})
print(user)

# 条件查询
for user in users_col.find({"age": {"$gt": 20}}).sort("age", -1):
    print(user)

# 3. 更新
users_col.update_one(
    {"name": "张三"},
    {"$set": {"age": 26}}
)

# 4. 删除
users_col.delete_one({"name": "张三"})

9.3 单例工具类封装

在项目中，我们通常会封装一个 MongoDB 工具类，保证全局只有一个连接。

from pymongo import MongoClient
from pymongo.errors import ServerSelectionTimeoutError

class MongoUtil:
    _instance = None
    _client = None
    
    def __init__(self):
        # 配置从配置文件读取
        self.uri = "mongodb://admin:password@localhost:27017/?authSource=admin"
        self.db_name = "test_db"
        self._init_client()
    
    @classmethod
    def get_instance(cls):
        if not cls._instance:
            cls._instance = MongoUtil()
        return cls._instance
    
    def _init_client(self):
        try:
            self._client = MongoClient(
                self.uri,
                maxPoolSize=100,
                serverSelectionTimeoutMS=5000
            )
            self._client.admin.command('ping')
        except Exception as e:
            raise Exception(f"MongoDB连接失败: {e}")
    
    def get_db(self):
        return self._client[self.db_name]
    
    def get_collection(self, col_name):
        return self.get_db()[col_name]

# 使用
mongo = MongoUtil.get_instance()
users_col = mongo.get_collection("users")

第十章：生产环境运维与最佳实践

10.1 监控

mongostat：实时监控 QPS、连接数、锁等状态。
mongotop：监控每个集合的读写耗时。
Prometheus + Grafana：搭建可视化监控面板。

10.2 备份恢复

mongodump / mongorestore：二进制备份，推荐生产环境使用。

# 备份
mongodump -d test_db -o /backup/20240504

# 恢复
mongorestore -d test_db /backup/20240504/test_db

mongoexport / mongoimport：导出 JSON/CSV 格式，适合数据迁移。

10.3 最佳实践

永远不要在生产环境开启公网访问，使用内网或 VPN。
永远开启认证，不要使用匿名访问。
合理设计 Schema，优先使用嵌入式文档，减少 Join。
不要过度索引，每个索引都会拖慢写入速度。
禁止大事务，事务会锁住资源，影响性能。
分页优化：深分页（大 skip）很慢，用 _id 游标分页代替。

参考资料

Date: 2026-05-04 Version: MongoDB 7.0