MongoDB相关概念

业务应用场景

传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。

解释：“三高”需求：

• High performance - 对数据库高并发读写的需求。
• Huge Storage - 对海量数据的高效率存储和访问的需求。
• High Scalability && High Availability- 对数据库的高可扩展性和高可用性的需求。

而MongoDB可应对“三高”需求。

具体的应用场景如：

1. 社交场景，使用 MongoDB 存储存储用户信息，以及用户发表的朋友圈信息，通过地理位置索引实现附近的人、地点等功能。
2. 游戏场景，使用 MongoDB 存储游戏用户信息，用户的装备、积分等直接以内嵌文档的形式存储，方便查询、高效率存储和访问。
3. 物流场景，使用 MongoDB 存储订单信息，订单状态在运送过程中会不断更新，以 MongoDB 内嵌数组的形式来存储，一次查询就能将订单所有的变更读取出来。
4. 物联网场景，使用 MongoDB 存储所有接入的智能设备信息，以及设备汇报的日志信息，并对这些信息进行多维度的分析。
5. 视频直播，使用 MongoDB 存储用户信息、点赞互动信息等。

这些应用场景中，数据操作方面的共同特点是：

1. 数据量大
2. 写入操作频繁（读写都很频繁）
3. 价值较低的数据，对事务性要求不高

对于这样的数据，我们更适合使用MongoDB来实现数据的存储。

什么时候选择MongoDB?

在架构选型上，除了上述的三个特点外，如果你还犹豫是否要选择它？可以考虑以下的一些问题：

应用不需要事务及复杂 join 支持
新应用，需求会变，数据模型无法确定，想快速迭代开发
应用需要2000-3000以上的读写QPS（更高也可以）
应用需要TB甚至 PB 级别数据存储
应用发展迅速，需要能快速水平扩展
应用要求存储的数据不丢失
应用需要99.999%高可用
应用需要大量的地理位置查询、文本查询

如果上述有1个符合，可以考虑 MongoDB，2个及以上的符合，选择 MongoDB 绝不会后悔。

思考：如果用MySQL呢？

答：相对MySQL，可以以更低的成本解决问题（包括学习、开发、运维等成本）

MongoDB简介

MongoDB是一个开源、高性能、无模式的文档型数据库，当初的设计就是用于简化开发和方便扩展，是NoSQL数据库产品中的一种。是最
像关系型数据库（MySQL）的非关系型数据库。

它支持的数据结构非常松散，是一种类似于 JSON 的 格式叫BSON，所以它既可以存储比较复杂的数据类型，又相当的灵活。

MongoDB中的记录是一个文档，它是一个由字段和值对（field:value）组成的数据结构。MongoDB文档类似于JSON对象，即一个文档认
为就是一个对象。字段的数据类型是字符型，它的值除了使用基本的一些类型外，还可以包括其他文档、普通数组和文档数组。

体系结构

数据模型

MongoDB的最小存储单位就是文档(document)对象。文档(document)对象对应于关系型数据库的行。数据在MongoDB中以 BSON（Binary-JSON）文档的格式存储在磁盘上。

BSON（Binary Serialized Document Format）是一种类json的一种二进制形式的存储格式，简称Binary JSON。BSON和JSON一样，支持内嵌的文档对象和数组对象，但是BSON有JSON没有的一些数据类型，如Date和BinData类型。

BSON采用了类似于 C 语言结构体的名称、对表示方法，支持内嵌的文档对象和数组对象，具有轻量性、可遍历性、高效性的三个特点，可以有效描述非结构化数据和结构化数据。这种格式的优点是灵活性高，但它的缺点是空间利用率不是很理想。

Bson中，除了基本的JSON类型：string,integer,boolean,double,null,array和object，mongo还使用了特殊的数据类型。这些类型包括

date,object id,binary data,regular expression 和code。每一个驱动都以特定语言的方式实现了这些类型，查看你的驱动的文档来获取详细信息。

BSON数据类型参考列表：

提示：

shell默认使用64位浮点型数值。{“x”：3.14}或{“x”：3}。对于整型值，可以使用NumberInt（4字节符号整数）或NumberLong（8字节符号整数），{“x”:NumberInt(“3”)}{“x”:NumberLong(“3”)}

MongoDB的特点

MongoDB主要有如下特点：

（1）高性能：

MongoDB提供高性能的数据持久性。特别是对嵌入式数据模型的支持减少了数据库系统上的I/O活动。

索引支持更快的查询，并且可以包含来自嵌入式文档和数组的键。（文本索引解决搜索的需求、TTL索引解决历史数据自动过期的需求、地理位置索引可用于构建各种 O2O 应用）

mmapv1、wiredtiger、mongorocks（rocksdb）、in-memory 等多引擎支持满足各种场景需求。

Gridfs解决文件存储的需求。

（2）高可用性：

MongoDB的复制工具称为副本集（replica set），它可提供自动故障转移和数据冗余。

（3）高扩展性：

MongoDB提供了水平可扩展性作为其核心功能的一部分。分片将数据分布在一组集群的机器上。（海量数据存储，服务能力水平扩展）从3.4开始，MongoDB支持基于片键创建数据区域。在一个平衡的集群中，MongoDB将一个区域所覆盖的读写只定向到该区域内的那些片。

（4）丰富的查询支持：

MongoDB支持丰富的查询语言，支持读和写操作(CRUD)，比如数据聚合、文本搜索和地理空间查询等。

（5）其他特点：如无模式（动态模式）、灵活的文档模型

docker 安装 mongodb

如果不知道 windows 如何安装 docker 的可以看我这篇文章

打开一个 cmd，按照下列步骤操作

1. 拉取最新镜像：docker pull mongo

2. 启动 mongodb 命令：docker run -d --name mongo -p 27017:27017 mongo --auth

   • docker run: 启动一个容器
   • -d 后台启动模式
   • –name mongo 容器的名字叫做 mongo，这里也可以叫其他的名字
   • -p 27017:27017[主机端口号:容器端口号]，端口号映射，到时候直接访问主机的 27017 就是在访问 mongo 数据库
   • mongo 这里的mongo是镜像名，指定使用哪个镜像启动容器
   • –auth: mongo 默认是不需要账号密码校验的，这里开启校验

3. 通过 docker 开启一个窗口访问 mongo：docker exec -it mongo mongosh

   • docker exec: docker 进入一个容器的命令
   • -it：以交互模式进入
   • mongo：这里的 mongo 是容器名字，而非镜像，因为我前面创建容器的时候就指定了这个名字。
   • mongosh：进入容器的时候要执行的命令，而 mongosh， 就是启动一个与mongodb 交互的 shell 窗口给我们使用。

至此安装完成。

进来的时候什么也没有。其他的安装方式我不太清楚，通过我这种方式安装的 mongodb，因为没有账号，因此什么也做不了，需要做一下初始化工作。而一旦初始化完成之后，再以无账号的身份进去的话，是没办法创建用户的。

初始化

在admin数据库中通过创建一个用户，赋予用户root权限。

# 进入 admin 数据库
test> use admin;
switched to db admin

# 创建 root 用户
admin> db.createUser(
...     {
...         user:"root",
...         pwd:"123456",
...         roles:[{role:"root",db:"admin"}]
...     }
... );
{ ok: 1 }

# 授权登录
admin> db.auth('root', '123456');
{ ok: 1 }

再次尝试查询 admin 数据库有哪些集合

关于 mongodb 的用户校验，权限校验什么的，需要专门讲述，后续再讲。

数据库

创建数据库
MongoDB 中默认的数据库为 test，如果你没有选择数据库，集合将存放在 test 数据库中。另外：

数据库名可以是满足以下条件的任意UTF-8字符串。

• 不能是空字符串（“”)。
• 不得含有’ '（空格)、.、$、/、\和\0 (空字符)。
• 应全部小写。
• 最多64字节。

有一些数据库名是保留的，可以直接访问这些有特殊作用的数据库。

• admin： 从权限的角度来看，这是"root"数据库。要是将一个用户添加到这个数据库，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器。
• local: 这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合
• config: 当Mongo用于分片设置时，config数据库在内部使用，用于保存分片的相关信息。

mongodb 的数据库无需主动创建，也没有显示的创建命令，比如你使用 use dbname，哪怕是一个不存在的数据库，也会给你已经进去了的错觉，其实什么都没有，数据库也没有创建。

这里我先进入了 test，数据库，然后查询所有的数据库，当前数据库中没有 test 数据库，然后我进入了 test2 数据库，还是没有 test2 数据库。

可以选择进入任何一个数据库，哪怕是不存在的数据库，只有向数据库中写入数据，才会真正的创建数据库。比如我们用命令显示的创建一个集合（表）

假如我们删除了这个表，这个数据库就会消失。

数据库删除

1. 数据库中的数据都没了，数据库也就没了，包括这个数据库的用户权限角色什么的，这些后面再说。
2. 显示的数据库删除命令。

集合

集合的命名规范：

• 集合名不能是空字符串""。
• 集合名不能含有\0字符（空字符)，这个字符表示集合名的结尾。
• 集合名不能以"system."开头，这是为系统集合保留的前缀。
• 用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含，这是因为某些系统生成的集合中包含该字符。除非你要访问这种系统创建的集合，否则千万不要在名字里出现$。

创建集合

直接显示创建集合：

test2> db.createCollection('category');
{ ok: 1 }
test2> show collections;
category

隐式创建集合：

当向一个集合中插入一个文档的时候，如果集合不存在，则会自动创建集合。通常我们使用隐式创建即可。

test2> show collections;
category
test2> db.partner.insert({})
DeprecationWarning: Collection.insert() is deprecated. Use insertOne, insertMany, or bulkWrite.
{
  acknowledged: true,
  insertedIds: { '0': ObjectId('658ceddc24b29552c8e7befb') }
}
test2> show collections;
category
partner
test2>

第一条集合展示命令显示 test2 数据库中只有 category 这一个集合，随后我们使用 db.partner.insert({})命令尝试向 partner 集合中插入一个空文档。这个时候 mongodb 首先会隐式创建一个 partner 的集合，然后向其中写入一条空文档。

注意：mongodb 告诉我们，insert 方法过时了，让我们使用 insertOne 等新的方法。

集合删除

test2> show collections;
category
partner
test2> db.category.drop();
true
test2> db.partner.drop();
true
test2> show collections;

test2>

文档

文档（document）的数据结构和 JSON 基本一样。所有存储在集合中的数据都是 BSON 格式.

插入

3.2 版本之后新增了 db.collection.insertOne() 和 db.collection.insertMany()。

单条插入 支持writeConcern

db.collection.insertOne(
	<document>,
	{writeConcern: <document>}
)

writeConcern 决定一个写操作落到多少个节点上才算成功。writeConcern 的取值包括：

• 0：发起写操作，不关心是否成功；
• 1~集群最大数据节点数：写操作需要被复制到指定节点数才算成功；
• majority：写操作需要被复制到大多数节点上才算成功.

insert: 若插入的数据主键已经存在，则会抛 DuplicateKeyException 异常，提示主键重复，不保存当前数据。

save: 如果 _id 主键存在则更新数据，如果不存在就插入数据。

批量插入

• insertMany: 向指定集合中插入多条文档数据

db.collection.insertMany(
	[ <document 1> , <document 2>, ... ],
	{
		writeConcern: <document>,
		ordered: <boolean>
	}
)

• writeConcern：写入策略，默认为 1，即要求确认写操作，0 是不要求。
• ordered：指定是否按顺序写入，默认 true，按顺序写入。

mongodb 是可以直接执行 js 代码的，这里使用 js 代码批量生成数据。

测试：批量插入50条随机数据

var tags = ["nosql","mongodb","document","developer","popular"];
var types = ["technology","sociality","travel","novel","literature"];
var books=[];
for(var i=0;i<50;i++){
    var typeIdx = Math.floor(Math.random()*types.length);
    var tagIdx = Math.floor(Math.random()*tags.length);
    var favCount = Math.floor(Math.random()*100);
    var book = {
        title: "book-"+i,
        type: types[typeIdx],
        tag: tags[tagIdx],
        favCount: favCount,
        author: "xxx"+i
    };
    books.push(book);
}
db.books.insertMany(books);

提示：

• 插入时指定了 _id ，则主键就是该值。
• 如果某条数据插入失败，将会终止插入，但已经插入成功的数据不会回滚掉。
• 因为批量插入由于数据较多容易出现失败，因此，可以使用try catch进行异常捕捉处理，测试的时候可以不处理。

查询

find 查询集合中的若干文档。语法格式如下：

db.collection.find(query, projection)

• query ：可选，使用查询操作符指定查询条件
• projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。投影时，id为1的时候，其他字段必须是1；id是0的时候，其他字段可以是0；如果没有_id字段约束，多个其他字段必须同为0或同为1。

如果查询返回的条目数量较多，mongo shell则会自动实现分批显示。默认情况下每次只显示20条，可以输入it命令读取下一批。

findOne查询集合中的第一个文档。语法格式如下:

db.collection.findOne(query, projection)

条件查询

指定条件查询

#查询带有nosql标签的book文档：
db.books.find({tag:"nosql"})
#按照id查询单个book文档：
db.books.find({_id:ObjectId("61caa09ee0782536660494d9")})
#查询分类为“travel”、收藏数超过60个的book文档：
db.books.find({type:"travel",favCount:{$gt:60}})

查询条件对照表

查询逻辑对照表

查询逻辑运算符

• $lt: 存在并小于
• $lte: 存在并小于等于
• $gt: 存在并大于
• $gte: 存在并大于等于
• $ne: 不存在或存在但不等于
• $in: 存在并在指定数组中
• $nin: 不存在或不在指定数组中
• $or: 匹配两个或多个条件中的一个
• $and: 匹配全部条件

排序&分页

指定排序

在 MongoDB 中使用 sort() 方法对数据进行排序

#指定按收藏数（favCount）降序返回
db.books.find({type:"travel"}).sort({favCount:-1})

分页查询

skip用于指定跳过记录数，limit则用于限定返回结果数量。可以在执行find命令的同时指定 skip、limit 参数，以此实现分页的功能。比如，假定每页大小为8条，查询第3页的book文档：

db.books.find().skip(8).limit(4)

正则表达式匹配查询

MongoDB 使用 $regex 操作符来设置匹配字符串的正则表达式

//使用正则表达式查找type包含 so 字符串的book
db.books.find({type: {$regex: "so"}})
//或者
db.books.find({type: /so/})

更新文档

可以用update命令对指定的数据进行更新，命令的格式如下：

db.collection.update(query, update, options);

• query：描述更新的查询条件；
• update：描述更新的动作及新的内容；
• options：描述更新的选项
  • upsert: 可选，如果不存在update的记录，是否插入新的记录。默认false，不插入
  • multi: 可选，是否按条件查询出的多条记录全部更新。 默认false,只更新找到的第一条记录
  • writeConcern :可选，决定一个写操作落到多少个节点上才算成功。

更新操作符

更新单个文档

某个book文档被收藏了，则需要将该文档的favCount字段自增

db.books.update({_id: ObjectId('658d031c24b29552c8e7befd')}, {$inc :{favCount: 1}});

更新多个文档

默认情况下，update命令只在更新第一个文档之后返回，如果需要更新多个文档，则可以使用multi选项。

将分类为“novel”的文档的增加发布时间（publishedDate）

db.books.update({type: "novel"}, {$set: {publishedDate: new Date()}}, {"multi": true});

multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新

update命令的选项配置较多，为了简化使用还可以使用一些快捷命令:

• updateOne：更新单个文档。
• updateMany：更新多个文档。
• replaceOne：替换单个文档。

使用upsert命令

upsert是一种特殊的更新，其表现为如果目标文档不存在，则执行插入命令。

db.books.update(
    {title: "my book"},
    {$set: {tags: ["nosql", "mongodb"], type: "none", author: "fox"}},
    {upsert: true}
)

nMatched、nModified都为0，表示没有文档被匹配及更新，nUpserted=1提示执行了upsert动作

findAndModify命令

findAndModify兼容了查询和修改指定文档的功能，findAndModify只能更新单个文档

//将某个book文档的收藏数（favCount）加1
db.books.findAndModify({
	query: {_id: ObjectId('658d031c24b29552c8e7bf10')},
	update: {$inc: {favCount: 1}}
});

该操作会返回符合查询条件的文档数据，并完成对文档的修改。

默认情况下，findAndModify会返回修改前的“旧”数据。如果希望返回修改后的数据，则可以指定new选项

//将某个book文档的收藏数（favCount）加1
db.books.findAndModify({
	query: {_id: ObjectId('658d031c24b29552c8e7bf10')},
	update: {$inc: {favCount: 1}},
	new: true
});

与findAndModify语义相近的命令如下：

• findOneAndUpdate：更新单个文档并返回更新前（或更新后）的文档。
• findOneAndReplace：替换单个文档并返回替换前（或替换后）的文档。

删除文档

使用 remove 删除文档

• remove 命令需要配合查询条件使用；
• 匹配查询条件的文档会被删除；
• 指定一个空文档条件会删除所有文档；

示例：

db.books.remove({_id: ObjectId('658d031c24b29552c8e7bf10')});  // 删除特定id 的数据
db.books.remove({favCount: {$lt: 20}});  // 删除 favCount 小于 25 的所有数据
db.books.remove({});  //删除整个集合中的所有的文档
db.books.remove();  // 报错

remove命令会删除匹配条件的全部文档，如果希望明确限定只删除一个文档，则需要指定justOne参数，命令格式如下：

db.collection.remove(query, justOne)

例如：删除满足type:novel条件的首条记录

db.books.remove({type: "novel"}, true)

使用 delete 删除文档

官方推荐使用 deleteOne() 和 deleteMany() 方法删除文档，语法格式如下：

db.books.deleteMany({}) //删除集合下全部文档
db.books.deleteMany({type: "novel"}) //删除 type等于 novel 的全部文档
db.books.deleteOne({type: "novel"}) //删除 type等于novel 的一个文档

注意： remove、deleteMany等命令需要对查询范围内的文档逐个删除，如果希望删除整个集合，则使用drop命令会更加高效

返回被删除文档

remove、deleteOne等命令在删除文档后只会返回确认性的信息，如果希望获得被删除的文档，则可以使用findOneAndDelete命令

db.books.findOneAndDelete({type:"novel"})

除了在结果中返回删除文档，findOneAndDelete命令还允许定义“删除的顺序”，即按照指定顺序删除找到的第一个文档

db.books.findOneAndDelete({type:"novel"},{sort:{favCount:1}})

remove、deleteOne等命令只能按默认顺序删除，利用这个特性，findOneAndDelete可以实现队列的先进先出。

聚合操作

聚合操作处理数据记录并返回计算结果(诸如统计平均值，求和等)。聚合操作组值来自多个文档，可以对分组数据执行各种操作以返回单个结果。聚合操作包含三类：单一作用聚合、聚合管道、MapReduce。

• 单一作用聚合：提供了对常见聚合过程的简单访问，操作都从单个集合聚合文档。
• 聚合管道是一个数据聚合的框架，模型基于数据处理流水线的概念。文档进入多级管道，将文档转换为聚合结果。
• MapReduce操作具有两个阶段：处理每个文档并向每个输入文档发射一个或多个对象的map阶段，以及reduce组合map操作的输出阶段。

单一作用聚合

MongoDB提供 db.collection.estimatedDocumentCount(), db.collection.count(), db.collection.distinct() 这类单一作用的聚合函数。 所有这些操作都聚合来自单个集合的文档。虽然这
些操作提供了对公共聚合过程的简单访问，但它们缺乏聚合管道和map-Reduce的灵活性和功能。

#检索books集合中所有文档的计数
db.books.estimatedDocumentCount()
#计算与查询匹配的所有文档
db.books.count({favCount: {$gt: 50}})
#返回不同type的数组
db.books.distinct("type")
#返回收藏数大于90的文档不同type的数组
db.books.distinct("type", {favCount: {$gt: 90}})

注意：在分片群集上，如果存在孤立文档或正在进行块迁移，则db.collection.count()没有查询谓词可能导致计数不准确。要避免这些情况，请在分片群集上使用 db.collection.aggregate()方法。

聚合管道

什么是 MongoDB 聚合框架

MongoDB 聚合框架（Aggregation Framework）是一个计算框架，它可以：

• 作用在一个或几个集合上；
• 对集合中的数据进行的一系列运算；
• 将这些数据转化为期望的形式；

从效果而言，聚合框架相当于 SQL 查询中的GROUP BY、 LEFT OUTER JOIN 、 AS等。

管道（Pipeline）和阶段（Stage）

整个聚合运算过程称为管道（Pipeline），它是由多个阶段（Stage）组成的， 每个管道：

• 接受一系列文档（原始数据）；
• 每个阶段对这些文档进行一系列运算；
• 结果文档输出给下一个阶段；

聚合管道操作语法

pipeline = [$stage1, $stage2, ...$stageN];
db.collection.aggregate(pipeline, {options})

• pipelines 一组数据聚合阶段。除 $out、$Merge 和 $geonear 阶段之外，每个阶段都可以在管道中出现多次。
• options 可选，聚合操作的其他参数。包含：查询计划、是否使用临时文件、 游标、最大操作时间、读写策略、强制索引等等

常用的管道聚合阶段

聚合管道包含非常丰富的聚合阶段，下面是最常用的聚合阶段

数据准备

准备数据集，执行脚本

var tags = ["nosql", "mongodb", "document", "developer", "popular"];
var types = ["technology", "sociality", "travel", "novel", "literature"];
var books = [];

for(var i=0;i<50;i++){
	var typeIdx = Math.floor(Math.random() * types.length);
	var tagIdx = Math.floor(Math.random() * tags.length);
	var tagIdx2 = Math.floor(Math.random() * tags.length);
	var favCount = Math.floor(Math.random() * 100);
	var username = "xx00" + Math.floor(Math.random() * 10);
	var age = 20 + Math.floor(Math.random() * 15);
	var book = {
		title: "book-"+i,
		type: types[typeIdx],
		tag: [tags[tagIdx],tags[tagIdx2]],
		favCount: favCount,
		author: {name: username, age: age}
	};
	books.push(book)
}
db.books.insertMany(books);

$project

投影操作， 将原始字段投影成指定名称， 如将集合中的 title 投影成 name

db.books.aggregate([{$project: {name: "$title"}}]);

$project 可以灵活控制输出文档的格式，也可以剔除不需要的字段

db.books.aggregate([{$project: {name: "$title", _id: 0, type: 1, auth: 1}}]);

从嵌套文档中排除字段

db.books.aggregate([
    {$project: {name: "$title", _id: 0, type: 1, "author.name": 1}}
])
或者
db.books.aggregate([
    {$project: {name: "$title", _id: 0, type: 1, author: {name: 1}}}
])

$match

$match用于对文档进行筛选，之后可以在得到的文档子集上做聚合，$match可以使用除了地理空间之外的所有常规查询操作符，在实际应用中尽可能将$match放在管道的前面位置。这样有两个好处：一是可以快速将不需要的文档过滤掉，以减少管道的工作量；二是如果再投射和分组之前执行$match，查询可以使用索引。

db.books.aggregate([{$match: {type: "technology"}}])

筛选管道操作和其他管道操作配合时候时，尽量放到开始阶段，这样可以减少后续管道操作符要操作的文档数，提升效率.

$count

计数并返回与查询匹配的结果数

db.books.aggregate([{$match: {type: "technology"}}, {$count: "type_count"}]);

$match阶段筛选出type匹配technology的文档，并传到下一阶段；

$count阶段返回聚合管道中剩余文档的计数，并将该值分配给type_count

$group

按指定的表达式对文档进行分组，并将每个不同分组的文档输出到下一个阶段。输出文档包含一个_id字段，该字段按键包含不同的组。

输出文档还可以包含计算字段，该字段保存由$group的_id字段分组的一些accumulator表达式的值。$group不会输出具体的文档而只是统计信息。

{$group: {_id: <expression>, <field1>: {<accumulator1>: <expression1>}, ...
}}

• _id字段是必填的;但是，可以指定id值为null来为整个输入文档计算累计值。
• 剩余的计算字段是可选的，并使用运算符进行计算。
• _id和表达式可以接受任何有效的表达式。

accumulator操作符

$group阶段的内存限制为100M。默认情况下，如果stage超过此限制，$group将产生错误。但是，要允许处理大型数据集，请将allowDiskUse选项设置为true以启用$group操作以写入临时文件。

book的数量，收藏总数和平均值

db.books.aggregate([
	{$group: {_id: null, count: {$sum: 1}, pop: {$sum: "$favCount"}, avg: {$avg: "$favCount"}}}
]);

注意：这里的 _id 不是每个文档的 _id，而是指定分组字段。

上述语义：没有分组字段，也就是说，数据组为全体数据。统计数据条数，输出字段为 count，统计收藏总和数量，输出字段为 pop，统计每本书的平均收藏数，输出字段为 avg。

统计每个作者的book收藏总数

db.books.aggregate([
	{$group: {_id: "$author.name", pop: {$sum: "$favCount"}}}
]);

这里 _id 指定了分组字段为作者姓名，统计每个姓名下的收藏总数。

统计每个作者的每本book的收藏数

db.books.aggregate([
	{$group: {_id: {name: "$author.name", title: "$title"}, pop: {$sum: "$favCount"}}}
])

这里对数据集合按照作者+书本进行分组，统计每个组的收藏数

每个作者的book的type合集

db.books.aggregate([
	{$group: {_id: "$author.name", types: {$addToSet: "$type"}}}
])

这里按照作者姓名进行分组，收集每个作者的书本分类[不重复]

$unwind

可以将数组拆分为单独的文档

v3.2+支持如下语法：

{
	$unwind: {
		#要指定字段路径，在字段名称前加上$符并用引号括起来。
		path: <field path>,
		#可选,一个新字段的名称用于存放元素的数组索引。该名称不能以$开头。
		includeArrayIndex: <string>,
		#可选，default :false，若为true,如果路径为空，缺少或为空数组，则$unwind输出文档
		preserveNullAndEmptyArrays: <boolean>
	}
}

姓名为xx006的作者的book的tag数组拆分为多个文档

db.books.aggregate([
	{$match:{"author.name":"xx006"}},
	{$unwind:"$tag"}
])

每个作者的book的tag合集

db.books.aggregate([
	{$unwind: "$tag"},
	{$group: {_id: "$author.name", types: {$addToSet: "$tag"}}}
])

案例

示例数据

db.books.insertMany([
    {
        "title" : "book-51",
        "type" : "technology",
        "favCount" : 11,
        "tag":[],
        "author" : {
            "name" : "fox",
            "age" : 28
        }
    },{
        "title" : "book-52",
        "type" : "technology",
        "favCount" : 15,
        "author" : {
            "name" : "fox",
            "age" : 28
    }
    },{
        "title" : "book-53",
        "type" : "technology",
        "tag" : [
            "nosql",
            "document"
         ],
        "favCount" : 20,
        "author" : {
            "name" : "fox",
            "age" : 28
         }
    }
])

测试

# 使用includeArrayIndex选项来输出数组元素的数组索引
db.books.aggregate([
	{$match:{"author.name":"fox"}},
	{$unwind:{path:"$tag", includeArrayIndex: "arrayIndex"}}
])

# 使用preserveNullAndEmptyArrays选项在输出中包含缺少size字段，null或空数组的文档
db.books.aggregate([
{$match:{"author.name":"fox"}},
{$unwind:{path:"$tag", preserveNullAndEmptyArrays: true}}
])

$limit

限制传递到管道中下一阶段的文档数

db.books.aggregate([
	{$limit: 5 }
])

此操作仅返回管道传递给它的前5个文档。 $limit对其传递的文档内容没有影响。

注意：当$sort在管道中的$limit之前立即出现时，$sort操作只会在过程中维持前n个结果，其中n是指定的限制，而MongoDB只需要将n个项存储在内存中。

$skip

跳过进入stage的指定数量的文档，并将其余文档传递到管道中的下一个阶段

db.books.aggregate([
	{$skip: 5 }
])

此操作将跳过管道传递给它的前5个文档。 $skip对沿着管道传递的文档的内容没有影响。

$sort

对所有输入文档进行排序，并按排序顺序将它们返回到管道。

语法：

{ $sort: { <field1>: <sort order>, <field2>: <sort order> ... } }

要对字段进行排序，请将排序顺序设置为1或-1，以分别指定升序或降序排序，如下例所示：

db.books.aggregate([
	{$sort: {favCount: -1, title: 1}}
])

$lookup

Mongodb 3.2版本新增，主要用来实现多表关联查询， 相当关系型数据库中多表关联查询。每个输入待处理的文档，经过$lookup 阶段的处理，输出的新文档中会包含一个新生成的数组（可根据需要命名新key ）。数组列存放的数据是来自被Join集合的适配文档，如果没有，集合为空（即 为[ ])

语法：

db.collection.aggregate([{
	$lookup: {
		from: "<collection to join>",
		localField: "<field from the input documents>",
		foreignField: "<field from the documents of the from collection>",
		as: "<output array field>"
	}
})

注意：null = null 此为真

其语法功能类似于下面的伪SQL语句：

SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (
	SELECT *
	FROM <collection to join>
	WHERE <foreignField>= <collection.localField>
);

案例

数据准备

db.customer.insert({customerCode:1,name:"customer1",phone:"13112345678",address:"test1"})
db.customer.insert({customerCode:2,name:"customer2",phone:"13112345679",address:"test2"})
db.order.insert({orderId:1,orderCode:"order001",customerCode:1,price:200})
db.order.insert({orderId:2,orderCode:"order002",customerCode:2,price:400})
db.orderItem.insert({itemId:1,productName:"apples",qutity:2,orderId:1})
db.orderItem.insert({itemId:2,productName:"oranges",qutity:2,orderId:1})
db.orderItem.insert({itemId:3,productName:"mangoes",qutity:2,orderId:1})
db.orderItem.insert({itemId:4,productName:"apples",qutity:2,orderId:2})
db.orderItem.insert({itemId:5,productName:"oranges",qutity:2,orderId:2})
db.orderItem.insert({itemId:6,productName:"mangoes",qutity:2,orderId:2})

关联查询

db.customer.aggregate([{
	$lookup: {
		from: "order",
		localField: "customerCode",
		foreignField: "customerCode",
		as: "customerOrder"
	}
}])

db.order.aggregate([
	{
		$lookup: {
			from: "customer",
			localField: "customerCode",
			foreignField: "customerCode",
			as: "curstomer"
		}
	}, {
		$lookup: {
			from: "orderItem",
			localField: "orderId",
			foreignField: "orderId",
			as: "orderItem"
		}
	}
])