1 MongoDB体系结构

配置文件参考博客：【https://blog.csdn.net/yuanwei1144/article/details/103779345】

适用场景

对于MongoDB实际应用来讲，是否使用MongoDB需要根据项目的特定特点进行甄别，这就需要我们对MongoDB适用和不适用的场景有一定的了解。

根据MongoDB 官网的说明，MongoDB 的适用场景如下：

1.网站实时数据：mongoDB非常适合实时的插入，更新与查询，并具备网站实时数据存储所需的复制及高度伸缩性。

由于MongoDB独特的数据处理方式，可以将热点数据加载到内存，故而对查询来讲，会非常快（当然也会非常消耗内存）；同时由于采用了BSON的方式存储数据，故而对JSON格式数据具有非常好的支持性以及友好的表结构修改性，文档式的存储方式，数据友好可见；数据库的分片集群负载具有非常好的扩展性以及非常不错的自动故障转移（大赞）。

2.数据缓存：由于性能很高，MongoDB 也适合作为信息基础设施的缓存层。在系统重启之后，由MongoDB搭建的持久化缓存层可以避免下层的数据源过载。

3.大尺寸、低价值数据存储：使用传统的关系型数据库存储一些数据时可能会比较昂贵，在此之前，很多时候程序员往往会选择传统的文件进行存储。

4.高伸缩性场景：MongoDB 非常适合由数十或数百台服务器组成的数据库。MongoDB 的路线图中已经包含对MapReduce 引擎的内置支持。

5.对象或JSON 数据存储：MongoDB 的BSON 数据格式非常适合文档化格式的存储及查询。

不适用场景：

1.高度事务性系统：例如银行或会计系统。传统的关系型数据库目前还是更适用于需要大量原子性复杂事务的应用程序。

2.传统的商业智能应用：针对特定问题的BI 数据库会对产生高度优化的查询方式。对于此类应用，数据仓库可能是更合适的选择。

3.需要复杂SQL查询的问题。

如何抉择：

写操作MongoDB比传统数据库快的根本原因是Mongo使用的内存映射技术 － 写入数据时候只要在 内存里完成就可以返回给应用程序，这样并发量自然就很高。而保存到硬体的操作则在后台异步完 成。注意MongoDB在2.4就已经是默认安全写了（具体实现在驱动程序里），所以楼上有同学的回答 说是”默认不安全“应该是基于2.2或之前版本的。

读操作MongoDB快的原因是：

1）MongoDB的设计要求你常用的数据（working set)可以在内存里 装下。这样大部分操作只需要读内存，自然很快。

2）文档性模式设计一般会是的你所需要的数据都 相对集中在一起（内存或硬盘），大家知道硬盘读写耗时最多是随机读写所产生的磁头定位时间， 数据集中在一起则减少了关系性数据库需要从各个地方去把数据找过来（然后Join）所耗费的随机读 时间 另外一个就是Mongo是分布式集群所以可以平行扩展。目前一般的百万次并发 量都是通过几十上百个节点的集群同时实现。这一点MySQL基本无法做到（或者要花很大定制的代 价）

MongoDB可以对数据进行分片，因此在大数据量（大部分场景）都不需要对数据进行分表存储。

1.1 Nosql和MongoDB

NoSQL=Not Only SQL，支持类似SQL的功能， 与Relational Database相辅相成。其性能较高， 不使用SQL意味着没有结构化的存储要求(SQL为结构化的查询语句)，没有约束之后架构更加灵 活。

NoSQL数据库四大家族:

• 列存储 Hbase
• 键值(Key-Value)存储 Redis
• 图形存储 Neo4j
• 文档存储 MongoDB

MongoDB 是一个基于分布式文件存储的数据库，由 C++ 编写，可以为 WEB 应用提供可扩展、 高性能、易部署的数据存储解决方案。 MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库中功能最丰富、 最像关系数据库的。在高负载的情况下，通过添加更多的节点，可以保证服务器性能。

1.2 体系结构

1.3 MongoDB和RBMS对比

文档是一组键值(key-value)对(即 BSON)。MongoDB 的文档不需要设置相同的字段，并且相同的字段不需要相同的数据类型，这与关系型数据库有很大的区别，也是 MongoDB 非常突出的特点。

需要注意：

1. 文档中的键/值对是有序的。
2. 文档中的值不仅可以是在双引号里面的字符串，还可以是其他几种数据类型（甚至可以是整个嵌入的文档)。
3. MongoDB区分类型和大小写。
4. MongoDB的文档不能有重复的键。
5. 文档的键是字符串。除了少数例外情况，键可以使用任意UTF-8字符。

文档键命名规范：

① 键不能含有\0 (空字符)。这个字符用来表示键的结尾。
②.和$有特别的意义，只有在特定环境下才能使用。
③ 以下划线"_"开头的键是保留的(不是严格要求的)。

1.3 BSON

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

BSON可以 做为网络数据交换的一种存储形式,是一种schema-less的存储形式它的优点是灵活性高，但它的缺点是空间利用率不是很理想（需要保存数据类型）

{key:value,key2:value2} 这是一个BSON的例子，其中key是字符串类型,后面的value值，它的类型一般 是字符串,double,Array,ISODate等类型。

BSON有三个特点：轻量性、可遍历性、高效性

1.4 Mongo数据类型

几种重要的数据类型：

ObjectId

ObjectId 类似唯一主键，可以很快的去生成和排序，包含 12 bytes，含义是：

• 前 4 个字节表示创建 unix 时间戳,格林尼治时间 UTC 时间，比北京时间晚了 8 个小时
• 接下来的 3 个字节是机器标识码
• 紧接的两个字节由进程 id 组成 PID
• 最后三个字节是随机数

MongoDB 中存储的文档必须有一个 _id 键。这个键的值可以是任何类型的，默认是个 ObjectId 对象

由于 ObjectId 中保存了创建的时间戳，所以你不需要为你的文档保存时间戳字段，你可以通过 getTimestamp 函数来获取文档的创建时间

> var newObject = ObjectId()
> newObject.getTimestamp()
ISODate("2017-11-25T07:21:10Z")

ObjectId 转为字符串

> newObject.str
5a1919e63df83ce79df8b38f

字符串

BSON 字符串都是 UTF-8 编码。

时间戳

BSON 有一个特殊的时间戳类型用于 MongoDB 内部使用，与普通的 日期 类型不相关。 时间戳值是一个 64 位的值。其中：

• 前32位是一个 time_t 值（与Unix新纪元相差的秒数）
• 后32位是在某秒中操作的一个递增的序数

在单个 mongod 实例中，时间戳值通常是唯一的。

在复制集中， oplog 有一个 ts 字段。这个字段中的值使用BSON时间戳表示了操作时间。

BSON 时间戳类型主要用于 MongoDB 内部使用。在大多数情况下的应用开发中，你可以使用 BSON 日期类型。

日期

表示当前距离 Unix新纪元（1970年1月1日）的毫秒数。日期类型是有符号的, 负数表示 1970 年之前的日期。

> var mydate1 = new Date()     //格林尼治时间
> mydate1
ISODate("2018-03-04T14:58:51.233Z")
> typeof mydate1
object

> var mydate2 = ISODate() //格林尼治时间
> mydate2
ISODate("2018-03-04T15:00:45.479Z")
> typeof mydate2
object

这样创建的时间是日期类型，可以使用 JS 中的 Date 类型的方法。

返回一个时间类型的字符串：

> var mydate1str = mydate1.toString()
> mydate1str
Sun Mar 04 2018 14:58:51 GMT+0000 (UTC) 
> typeof mydate1str
string

或者

> Date()
Sun Mar 04 2018 15:02:59 GMT+0000 (UTC)

2 MongoDB安装

我这里使用的是docker安装centos镜像，然后在centos里面安装MongoDB的。

第一步：启动centos

• 拉取centos镜像 docker pull centos

• 启动centos
  12017 主要是用作mongodb绑定端口 1221为ssh server绑定端口
  启动使用 /usr/sbin/init 命令主要是要用systemctl命令

  docker run --name centos-v1 -itd -p 12017:12017 1221:22 centos:latest /usr/sbin/init

第二步：安装必要的工具包

• 进入centos 容器

  docker exec -it centos-v1 bash

• 安装open_server

  yum install openssh-server.x86_64

• 安装net-tools

  yum install net-tools

• 安装vim

  yum install vim

• 安装passwd命令

  yum install passwd

• 安装远程下载，上传工具

  yum install lrzsz

第三步：创建mongo目录并上传

• 在/usr/local目录下创建mongo目录

  cd /usr/local
  mkdir mongo

• 下载mongo server安装包
  使用cat /etc/redhat-release查看centos版本 我这里是

  [root@8477691e110c mongodb_4.4.1]# cat /etc/redhat-release
  CentOS Linux release 8.2.2004 (Core)

所以下载的是8.0版本的mongo。我这里是先下载到我本地，然后通过rz命令上传到/usr/local/mongo目录下。下载下来为mongodb-linux-x86_64-rhel80-4.4.1.tgz

• 然后rz命令上传

  rz

然后解压重命名

tar -zxvf mongodb-linux-x86_64-rhel80-4.4.1.tgz
mv mongodb-linux-x86_64-rhel80-4.4.1 mongodb_4.4.1

然后在mongodb_4.4.1创建 conf,data,logs目录。分别放配置文件，数据文件，日志文件

第四步：配置启动

• 在conf目录下创建mongod.conf

  touch mongod.conf

• 然后将以下配置copy到里面即可 ```yaml storage:

  存放数据路径

  dbPath: /usr/local/mongo/mongodb_4.4.1/data

  类似于redolog

  journal: enabled: true directoryPerDB: true engine: wiredTiger systemLog: destination: file

  日志存放文件

  path: /usr/local/mongo/mongodb_4.4.1/logs/mongod.log logAppend: true
  net: port: 12017 bindIp: 0.0.0.0

security:

访问集合是否需要登录权限校验

authorization: disabled

processManagement:

后台进程运行

fork: true

- 
启动
<br />在/usr/local/mongo/mongod_4.4.1下执行命令

./bin/mongod —config=/usr/local/mongo/mongodb_4.4.1/conf/mongod.conf

以上，mongod安装工作就大功告成了。
我们可以通过 ./bin/mongo --host localhost --port 12017连接就可以了
<a name="d45a720c"></a>
# 3 MongoDB连接
当我使用客户端url来连接MongoDB服务器时，注意以下参数的作用。
标准url连接：

mongodb://[username:password@]host1[:port1][,host2[:port2],…[,hostN[:portN]]][/[database][?options]]

- **mongodb://** 这是固定的格式，必须要指定。
- **username:password@** 可选项，如果设置，在连接数据库服务器之后，驱动都会尝试登陆这个数据库
- **host1** 必须的指定至少一个host, host1 是这个URI唯一要填写的。它指定了要连接服务器的地址。如果要连接复制集，请指定多个主机地址。
- **portX** 可选的指定端口，如果不填，默认为27017
- **/database** 如果指定username:password@，连接并验证登陆指定数据库。若不指定，默认打开 test 数据库。
- **?options** 是连接选项。**如果不使用/database，则前面需要加上/**。所有连接选项都是键值对name=value，键值对之间通过&或;（分号）隔开
| 选项 | 描述 |
| :--- | :--- |
| replicaSet=name | 验证replica set的名称。 Impliesconnect=replicaSet. |
| slaveOk=true|false | true:在connect=direct模式下，驱动会连接第一台机器，即使这台服务器不是主。在connect=replicaSet模式下，驱动会发送所有的写请求到主并且把读取操作分布在其他从服务器。false: 在 connect=direct模式下，驱动会自动找寻主服务器. 在connect=replicaSet 模式下，驱动仅仅连接主服务器，并且所有的读写命令都连接到主服务器。 |
| connect=direct|replicaSet | 默认是replicaSet |
| safe=true|false | true: 在执行更新操作之后，驱动都会发送getLastError命令来确保更新成功。(还要参考 wtimeoutMS).false: 在每次更新之后，驱动不会发送getLastError来确保更新成功。默认true |
| w=n | 驱动添加 { w : n } 到getLastError命令. 应用于safe=true。至少需要n个服务器成功写入 |
| wtimeoutMS=ms | 驱动添加 { wtimeout : ms } 到 getlasterror 命令. 应用于 safe=true. 超时时间。 |
| fsync=true|false | true: 驱动添加 { fsync : true } 到 getlasterror 命令.应用于 safe=true.false: 驱动不会添加到getLastError命令中。 |
| journal=true|false | 如果设置为 true, 同步到 journal (在提交到数据库前写入到实体中). 应用于 safe=true |
| connectTimeoutMS=ms | 可以打开连接的超时时间。 |
| socketTimeoutMS=ms | 发送和接受sockets的超时时间 |
使用用户名和密码连接登陆到指定数据库，格式如下：

mongodb://admin:123456@localhost:27017,ip2:port2/test

连接本地数据库服务器，端口是默认的。

mongodb://localhost

使用用户名fred，密码foobar登录localhost的admin数据库。

mongodb://fred:foobar@localhost

使用用户名fred，密码foobar登录localhost的baz数据库。

mongodb://fred:foobar@localhost/baz

连接 replica pair, 服务器1为example1.com服务器2为example2。

mongodb://example1.com:27017,example2.com:27017

连接 replica set 三台服务器 (端口 27017, 27018, 和27019):

mongodb://localhost,localhost:27018,localhost:27019

连接 replica set 三台服务器, 写入操作应用在主服务器 并且分布查询到从服务器。

mongodb://host1,host2,host3/?slaveOk=true

直接连接第一个服务器，无论是replica set一部分或者主服务器或者从服务器。

mongodb://host1,host2,host3/?connect=direct;slaveOk=true

当你的连接服务器有优先级，还需要列出所有服务器，你可以使用上述连接方式。
安全模式连接到localhost:

mongodb://localhost/?safe=true

以安全模式连接到replica set，并且等待至少两个复制服务器成功写入，超时时间设置为2秒。

mongodb://host1,host2,host3/?safe=true;w=2;wtimeoutMS=2000

<a name="e76c38e6"></a>
# 3 使用
可以像mysql 那样 使用 use dbName切换数据库。即使不存在也可以切换。只要创建了集合这个数据库就存在了。如果不存在集合，那么使用 show dbs（查看所有数据库）是没有的。
show tables/show collections 查看所有集合
删除数据库： db.dropDataBase()
删除集合： db.collectionName.drop() 比如db.user.drop()
如果安装的MongoDB服务需要鉴权。
还需要 db.auth(user,pwd)，不过使用db.auth()的时候需要先创建用户db.createUser()可以参考博文【[https://www.cnblogs.com/pl-boke/p/10063351.html](https://www.cnblogs.com/pl-boke/p/10063351.html%5D)】
更多命令：db.help()
地理位置的相关CRUD，参考文档【https://docs.mongodb.com/manual/geospatial-queries/#geospatial-data】
<a name="f222a526"></a>
## 4.1 创建集合
db.createCollection(name,options)
可选参数说明：
| 字段 | 类型 | 描述 |
| :--- | :--- | :--- |
| capped | 布尔 | （可选）如果为 true，则创建固定集合。固定集合是指有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。 **当该值为 true 时，必须指定 size 参数。** |
| autoIndexId | 布尔 | 3.2 之后不再支持该参数,会默认为_id列创建索引。（可选）如为 true，自动在 _id 字段创建索引。默认为 false。 |
| size | 数值 | （可选）为固定集合指定一个最大值，**以千字节计（KB**）。 **如果 capped 为 true，也需要指定该字段。** |
| max | 数值 | （可选）指定固定集合中包含文档的最大数量。 |
在插入文档时，MongoDB 首先检查固定集合的 size 字段，然后检查 max 字段。
比如：

db.createCollection(“mycol”, { capped : true, autoIndexId : true, size : 6142800, max : 10000 } ) { “ok” : 1 }

```

但是MongoDB不需要显示的创建集合，当插入文档数据时会自动创建：

> db.mycol2.insert({"name" : "w王豪"})
> show collections
mycol2

删除文档：

db.myCol2.drop()

我们也可以不通过createCollection创建。db.colName.insert()就可以，自动创建集合。

4.2 插入文档

集合名可以不存在，会自动创建。

db.colName.insert()

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

可以插入一条数据，也可以插入多条数据。

插入多条数据：

可以先创建一个数组，然后插入

>var arr = [{num:1},{num:2}];
>db.mycol2.insert(arr)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 2,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})
>db.mycol2.find()
{ "_id" : ObjectId("5f2953a06e9504b5b351f1d0"), "name" : "w王豪" }
{ "_id" : ObjectId("5f2955ad6e9504b5b351f1d1"), "name" : "w王豪" }
{ "_id" : ObjectId("5f295a806e9504b5b351f1d2"), "num" : 1 }
{ "_id" : ObjectId("5f295a806e9504b5b351f1d3"), "num" : 2 }

> var o = {_id:5,num:5}
> db.mycol2.insert(o)
WriteResult({ "nInserted" : 1 })
> db.mycol2.insert(o)
WriteResult({
        "nInserted" : 0,
        "writeError" : {
                "code" : 11000,
                "errmsg" : "E11000 duplicate key error collection: first.mycol2 index: _id_ dup key: { _id: 5.0 }"
        }
})

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

如果主键重复也会报错的。

db.collection.insertOne() 用于向集合插入一个新文档，语法格式如下：

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

db.collection.insertMany() 用于向集合插入一个多个文档，语法格式如下：

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

参数说明：

• document：要写入的文档。

• writeConcern：

  { w: <value>, j: <boolean>, wtimeout: <number> }
    w : 该选项要求确认操作已经传播到指定数量的mongod实例或指定标签的mongod实例
       w:1(应答式写入)
          要求确认操作已经传播到指定的单个mongod实例或副本集主实例(缺省为1)
       w:0(非应答式写入)
           不返回任何响应，所以无法知道写入是否成功
           但是对于尝试向已关闭的套接字写入或者网络故障会返回异常信息
       w:>1(用于副本集环境)
            该值用于设定写入节点的数目，包括主节点。如果value大于replica set中节点数也不会
            阻塞。
       "majority"(大多数)
            当数据写入到replica set的大多数节点之后向客户端返回，对于这种情况，一般是配合
            read-concern使用
       <tag set>
            要求写入操作已经传递到指定tag标记副本集中的成员后进行应答
    j : 该选项要求确认写操作已经写入journal日志之后应答客户端(需要开启journal功能)
            则在意外重启，宕机等情形下可以通过journal来进行数据恢复
            写入journal操作必须等待直到下次提交日志时完成写入
            为降低延迟，MongoDB可以通过增加commit journal的频率来加快journal写入
            对于w>1, 需要所有实例都写到journal之后才返回
            j:true时会强制journal日志刷盘。默认时100ms从log buffer刷盘一次
    wtimeout:
            该选项指定一个时间限制,以防止写操作无限制被阻塞导致无法应答给客户端
            wtimeout的单位为ms，当w值大于1时生效，该参数即仅适用于集群环境
            当某个节点写入时超出指定wtimeout之后，mongod将返回一个错误
            在捕获到超时之前，mongod并不会撤销其他节点已成功完成的写入
            wtimeout值为0时等同于没有配置wtimeout选项，容易导致由于某个节点挂起而无法应答
    对于单实例应答的情形，是将数据写入到内存后开始应答，除非j:true，则保证掉电后不会丢失数据

1、非应答式写入图示
![这里写图片描述](assets/20161024172337968-1618046910094)
      MongoDB不对客户端进行应答，驱动会检查套接字，网络错误等。
      mongos> db.version()
          3.2.9
      mongos> db.version()
          3.2.9
      mongos> db
      test
      mongos> db.blogs.insert({ename:"leshami",url:"http://blog.csdn.net/leshami"},{writeConcern:{w:0}})
          WriteResult({ })   //此处应答为空
      mongos> db.blogs.find({},{_id:0})
      { "ename" : "leshami", "url" : "http://blog.csdn.net/leshami" }
2、应答式写入图示
![这里写图片描述](assets/20161024172424766-1618046956519)
      应答式写入是默认值
      MongoDB会在收到写入操作并且确认该操作在内存中应用后进行应答，但不会确认数据是否已写入磁盘
    同时允许客户端捕捉网络、重复key等等错误
      mongos> db.blogs.insert({ename:"john",url:"http://blog.csdn.net/john"},{writeConcern:{w:1}})
      WriteResult({ "nInserted" : 1 })    //此处应答信息显示为1个文档已插入
      mongos> db.blogs.find({},{_id:0})
      { "ename" : "leshami", "url" : "http://blog.csdn.net/leshami" }
      { "ename" : "john", "url" : "http://blog.csdn.net/john" }
3、带journal应答式写入图示
![这里写图片描述](assets/20161024172513517)
      确认写操作已经写入journal日志之后应答客户端，必须允许了日志功能，才能生效。
      写入journal操作必须等待直到下次提交日志时完成写入
    提供通过journal来进行数据恢复
4、副本集应答写入图示
<img src="assets/20161024173434123" alt="这里写图片描述" style="zoom:67%;" />

对于使用副本集的场景，缺省情况下仅仅从主(首选)节点进行应答
建议修改缺省的应答情形为特定数目或者majority来保证数据的可靠
如下示例，w值为2，超时为5s

db.products.insert(
{ item: “envelopes”, qty : 100, type: “Clasp” },
{ writeConcern: { w: 2, wtimeout: 5000 } }
)

  如果不希望每次在增删改时添加writeConcern，可以通过设置settings.getLastErrorDefaults
 如下示例，

        cfg = rs.conf()<br />
        cfg.settings = {}<br />
        cfg.settings.getLastErrorDefaults = { w: "majority", wtimeout: 5000 }<br />
        rs.reconfig(cfg)<br />

3.2 之后 conf有一个属性 writeConcernMajorityJournalDefault可以直接进行配置。
cfg.writeConcernMajorityJournalDefault=true

而且在　在MongoDB3.4中，加入了[`writeConcernMajorityJournalDefault`](https://docs.mongodb.com/manual/reference/replica-configuration/#rsconf.writeConcernMajorityJournalDefault).这么一个选项，使得w，j在不同的组合下情况下不同:
![img](assets/1089769-20170521145428510-2009723647.png)
  四、小结
  1、write concern用于控制写入安全的级别，可以分为应答式写入以及非应答式写入
  2、write concern是一个性能和数据强一致性的权衡，应根据业务场景进行设定
  3、对于强一致性场景，建议w>1或者等于majority，以及journal为true，否则w=0
  4、在副本集的情形下，建议通过配置文件来修改w以及设置wtimeout，以避免由于某个节点挂起导致无法应答
比如：

var document = db.collection.insertOne({“a”: 3})
document
{
“acknowledged” : true,
“insertedId” : ObjectId(“571a218011a82a1d94c02333”)
}

插入多条数据

var res = db.collection.insertMany([{“b”: 3}, {‘c’: 4}])
res
{
“acknowledged” : true,
“insertedIds” : [
ObjectId(“571a22a911a82a1d94c02337”),
ObjectId(“571a22a911a82a1d94c02338”)
]
}

我们也可以先创建一个集合然后再使用insertMany()命令插入。
## 3.3 更新文档
db.collection.update()
db.collection.updateOne()
db.collection.updateMany()
可以set不存在的属性，如果不存在会添加属性。
语法：

db.collection.update(
,
,
{
upsert: ,
multi: ,
writeConcern:
}
)

**参数说明：**
- **query** : update的查询条件，类似sql update查询内where后面的。
- **update** : update的对象和一些更新的操作符（如$,$inc...）等，也可以理解为sql update查询内set后面的
- **upsert** : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
- **multi** : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
- **writeConcern** :可选，参考上面

db.col.insert({
title: ‘MongoDB 教程’,
description: ‘MongoDB 是一个 Nosql 数据库’,
by: ‘王豪’,
url: ‘http://www.trust.com‘,
tags: [‘mongodb’, ‘database’, ‘NoSQL’],
likes: 100
})

更新语句：
db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB',likes:38}})

db.col.update({‘title’:’MongoDB 教程’},{$set:{‘title’:’MongoDB’,likes:38}})
WriteResult({ “nMatched” : 1, “nUpserted” : 0, “nModified” : 1 })
db.col.find()
{ “_id” : ObjectId(“5f2960446e9504b5b351f1d4”), “title” : “MongoDB”, “description” : “MongoDB 是一个 Nosql 数据库”, “by” : “王豪”, “url” : “http://www.trust.com“, “tags” : [ “mongodb”, “database”, “NoSQL” ], “likes” : 38 }

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
返回结果：nMatched匹配数量 nUpserted插入数量 nModified更新数量
如果要更新满足多个条件的文档可以：
db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB',likes:38}},{multi:true})
如果更新的文档不存在则插入：
db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB',likes:380}},{upsert:true})
likes加100
db.col.update({title:'MongoDB教程},$incr:{likes:100}) 
注意点如果不加更新操作符 `$set`，`$unset`，`$incr` 是相当于替换整个文档。
还有一个更新操作命令
db.collection.updateOne(query,update,[options]) 这个是只更新一条数据
db.collection.updateMany(query,update,[options]) 这个是更新多条数据

name为赵六的不存在 会添加一条 name=赵六，age=23的数据

db.col2.updateMany({name:”赵六”},{%0A%23name%E4%B8%BA%E8%B5%B5%E5%85%AD%E7%9A%84%E4%B8%8D%E5%AD%98%E5%9C%A8%20%E4%BC%9A%E6%B7%BB%E5%8A%A0%E4%B8%80%E6%9D%A1%20name%3D%E9%99%88%E4%B8%83%EF%BC%8Cage%3D23%E7%9A%84%E6%95%B0%E6%8D%AE%0Adb.col2.updateMany(%7Bname%3A%22%E8%B5%B5%E5%85%AD%22%7D%2C%7B#card=math&code=set%3A%7B%22age%22%3A23%7D%7D%2C%7Bupsert%3Atrue%7D%29%0A%23name%E4%B8%BA%E8%B5%B5%E5%85%AD%E7%9A%84%E4%B8%8D%E5%AD%98%E5%9C%A8%20%E4%BC%9A%E6%B7%BB%E5%8A%A0%E4%B8%80%E6%9D%A1%20name%3D%E9%99%88%E4%B8%83%EF%BC%8Cage%3D23%E7%9A%84%E6%95%B0%E6%8D%AE%0Adb.col2.updateMany%28%7Bname%3A%22%E8%B5%B5%E5%85%AD%22%7D%2C%7B)set:{“age”:23,name:”陈七”}},{upsert:true})

## 4.4 删除文档
语法：

db.collection.remove(
,
{
justOne: ,
writeConcern:
}
)

**参数说明：**
- **query** :（可选）删除的文档的匹配条件。
- **justOne** : （可选）如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，则删除所有匹配条件的文档。
- **writeConcern** : 看前面
db.col.remove({likes:{$lt:39}})

db.col.find()
{ “_id” : ObjectId(“5f2960446e9504b5b351f1d4”), “title” : “MongoDB”, “description” : “MongoDB 是一个 Nosql 数据库”, “by” : “王豪”, “url” : “http://www.trust.com“, “tags” : [ “mongodb”, “database”, “NoSQL” ], “likes” : 38 }
{ “_id” : ObjectId(“5f29626d64050204c4d9abaa”), “title” : “MongoDB”, “likes” : 38 }
db.col.remove({likes:{%0AWriteResult(%7B%20%22nRemoved%22%20%3A%200%20%7D)%0Adb.col.remove(%7Blikes%3A%7B#card=math&code=lt%3A38%7D%7D%29%0AWriteResult%28%7B%20%22nRemoved%22%20%3A%200%20%7D%29%0Adb.col.remove%28%7Blikes%3A%7B)lt:39}})
WriteResult({ “nRemoved” : 2 })
db.col.find()

**remove方法已经过时了，而且remove不会真正的释放空间，需要执行命令来回收磁盘空间：**
db.repairDatabase()或者db.runCommand({repairDatabase:1})
现在推荐的命令：
db.collection.deleteMany({condition}) 删除满足条件的所有文档，如果db.collection.deleteMany({})会删除真个文档。 
db.collection.deleteOne({condition})删除满足条件的第一个文档
## 3.5 查询文档
语法：

db.collection.find(query, projection)

- **query** ：可选，使用查询操作符指定查询条件
- **projection** ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。
  假如user表中有_id,name,age三个字段
  比如只查询name,不查询age字段 如果不显式指定不查询_id，默认都会查询

db.user.find().pretty()
{ “_id” : ObjectId(“5f27f757da04113c34da38c9”), “name” : “王豪”, “age” : 23 }
{ “_id” : 2, “name” : “张三”, “age” : 24 }
{ “_id” : 3, “name” : “王五”, “age” : 25 }
{ “_id” : 4, “name” : “李四”, “age” : 26 }
{ “_id” : 5, “name” : “赵六”, “age” : “27岁” }
db.user.find({},{name:1}).pretty()
{ “_id” : ObjectId(“5f27f757da04113c34da38c9”), “name” : “王豪” }
{ “_id” : 2, “name” : “张三” }
{ “_id” : 3, “name” : “王五” }
{ “_id” : 4, “name” : “李四” }
{ “_id” : 5, “name” : “赵六” }

如果不查询_id
db.user.find({},{_id:0}).pretty()

db.user.find({},{_id:0}).pretty()
{ “name” : “王豪”, “age” : 23 }
{ “name” : “张三”, “age” : 24 }
{ “name” : “王五”, “age” : 25 }
{ “name” : “李四”, “age” : 26 }
{ “name” : “赵六”, “age” : “27岁” }

如果需要美观输出：

db.collection.find(query, projection).pretty()

db.col.find()
{ “_id” : ObjectId(“5f2968c06e9504b5b351f1d5”), “title” : “MongoDB 教程”, “description” : “MongoDB 是一个 Nosql 数据库”, “by” : “王豪”, “url” : “http://www.trust.com“, “tags” : [ “mongodb”, “database”, “NoSQL” ], “likes” : 100 }
db.col.find().pretty()
{
“_id” : ObjectId(“5f2968c06e9504b5b351f1d5”),
“title” : “MongoDB 教程”,
“description” : “MongoDB 是一个 Nosql 数据库”,
“by” : “王豪”,
“url” : “http://www.trust.com“,
“tags” : [
“mongodb”,
“database”,
“NoSQL”
],
“likes” : 100
}

testDat:

for (var i = 1000; i <= 2000; i++) {
db.testData.insert( { x : i , name: “MACLEAN” , name1:”MACLEAN”, name2:”MACLEAN”, name3:”MACLEAN”} )
}

**常用操作符**
如果你熟悉常规的 SQL 数据，通过下表可以更好的理解 MongoDB 的条件语句查询：
| 操作         | 格式         | 范例                                          | RDBMS中的类似语句            |
| :----------- | :----------- | :-------------------------------------------- | :--------------------------- |
| 等于=        | `{:`}        | db.testData.find({"name":"MACLEAN"}).pretty() | `where by = '菜鸟教程'`      |
| 小于<        | `{:{$lt:}}`  | db.testData.find({"x":{$lt:50}}).pretty()     | `where x < 50`               |
| 小于或等于<= | `{:{$lte:}}` | db.testData.find({"x":{$lte:50}}).pretty()    | `where x <= 50`              |
| 大于>        | `{:{$gt:}}`  | db.testData.find({"x":{$gt:50}}).pretty()     | `where x > 50`               |
| 大于或等于>= | `{:{$gte:}}` | db.testData.find({"x":{$gte:50}}).pretty()    | `where x >= 50`              |
| 不等于<>     | `{:{$ne:}}`  | db.testData.find({"x":{$ne:50}}).pretty()     | where x!=50或者 where x<> 50 |
如果多个条件and 可以用分号隔开，如下

db.testData.find({“name”:”MACLEAN”,x:{lt:1090}}).pretty()

{ “_id” : ObjectId(“5f2952366e9504b5b351edf9”), “x” : 1018, “name” : “MACLEAN”, “name1” : “MACLEAN”, “name2” : “MACLEAN”, “name3” : “MACLEAN” }
{ “_id” : ObjectId(“5f2952366e9504b5b351edfa”), “x” : 1019, “name” : “MACLEAN”, “name1” : “MACLEAN”, “name2” : “MACLEAN”, “name3” : “MACLEAN” }
Type “it” for more

db.testData.find({“name”:”MACLEAN”,x:{lt:1090}}).pretty()
{
“_id” : ObjectId(“5f2952366e9504b5b351ee3f”),
“x” : 1088,
“name” : “MACLEAN”,
“name1” : “MACLEAN”,
“name2” : “MACLEAN”,
“name3” : “MACLEAN”
}
{
“_id” : ObjectId(“5f2952366e9504b5b351ee40”),
“x” : 1089,
“name” : “MACLEAN”,
“name1” : “MACLEAN”,
“name2” : “MACLEAN”,
“name3” : “MACLEAN”
}

**or的语法**：

db.col.find(
{
$or: [
{key1: value1}, {key2:value2}
]
}
).pretty()

可以and 和 or一起用
类似于sql的
where x > 1010 and x < 1090 and (name = '哈哈‘ or name1= ’哟哟‘)

db.testData.find({x:{lt:1090},$or:[{name:’哈哈’},{name1:’哟哟’}]}).pretty()

db.testData.find({x:{lt:1090},$or:[{name:’哈哈’},{name1:’哟哟’}]}).pretty()
{
“_id” : ObjectId(“5f2952366e9504b5b351edfa”),
“x” : 1019,
“name” : “哈哈”,
“name1” : “MACLEAN”,
“name2” : “MACLEAN”,
“name3” : “MACLEAN”
}
{
“_id” : ObjectId(“5f2952366e9504b5b351ee04”),
“x” : 1029,
“name” : “MACLEAN”,
“name1” : “哟哟”,
“name2” : “MACLEAN”,
“name3” : “MACLEAN”
}

student的数据：
![image-20200929142124937](assets/image-20200929142124937.png)
也可以实现类似 select * from student where major="电子信息" or (school='武汉纺织大学' and major='服装设计')

db.student.find({$or:[{school:’武汉纺织大学’,major:’服装设计’},{major:’电子信息’}]})

![image-20200929142050987](assets/image-20200929142050987.png)
**模糊查询：** 注意//中间是没有单引号或者双引号的

db.user.find().pretty()
{ “_id” : ObjectId(“5f27f757da04113c34da38c9”), “name” : “王豪”, “age” : 23 }
{ “_id” : 2, “name” : “张三”, “age” : 24 }
{ “_id” : 3, “name” : “王五”, “age” : 25 }
{ “_id” : 4, “name” : “李四”, “age” : 26 }

name包含王的文档

db.user.find({name:/王/}).pretty()

db.user.find({name:/王/}).pretty()
{ “_id” : ObjectId(“5f27f757da04113c34da38c9”), “name” : “王豪”, “age” : 23 }
{ “_id” : 3, “name” : “王五”, “age” : 25 }

name以张开头的文档

db.user.find({name:/^张/}).pretty()

db.user.find({name:/^张/}).pretty()
{ “_id” : 2, “name” : “张三”, “age” : 24 }

name以四结尾的文档

db.user.find({name:/四$/}).pretty()

db.user.find({name:/四$/}).pretty()
{ “_id” : 4, “name” : “李四”, “age” : 26 }

in 查询

db.user.find({name:{$in:[“张三”,”李四”]}}).pretty()

all 查询

$all:满足所有元素的数据符合列表里面元素条件就可以 显示数据

db.user.find({hobby:{$all:[“足球”] } })
{ “_id” : ObjectId(“5ca7a4c4219efd687462f968”), “id” : 4, “name” : “xiaogang”, “age” : 34, “hobby” : [ “羽毛球”, “篮球”, “足球” ] }

db.user.find({hobby:{$all:[“足球”,”羽毛球”] } })
{ “_id” : ObjectId(“5ca7a4c4219efd687462f968”), “id” : 4, “name” : “xiaogang”, “age” : 34, “hobby” : [ “羽毛球”, “篮球”, “足球” ] }

db.user.find({hobby:{$all:[“足球”,”桌球”] } })

$type操作符：
因为MongoDB对相同字段的每个文档的数据类型不做限制，因此我们可以通过数据类型进行筛选。
| **类型**                | **数字** | **备注**         |
| :---------------------- | :------- | :--------------- |
| Double                  | 1        |                  |
| String                  | 2        |                  |
| Object                  | 3        |                  |
| Array                   | 4        |                  |
| Binary data             | 5        |                  |
| Undefined               | 6        | 已废弃。         |
| Object id               | 7        |                  |
| Boolean                 | 8        |                  |
| Date                    | 9        |                  |
| Null                    | 10       |                  |
| Regular Expression      | 11       |                  |
| JavaScript              | 13       |                  |
| Symbol                  | 14       |                  |
| JavaScript (with scope) | 15       |                  |
| 32-bit integer          | 16       |                  |
| Timestamp               | 17       |                  |
| 64-bit integer          | 18       |                  |
| Min key                 | 255      | Query with `-1`. |
| Max key                 | 127      |                  |

db.user.find().pretty() ))
{ “_id” : ObjectId(“5f27f757da04113c34da38c9”), “name” : “王豪”, “age” : 23 }
{ “_id” : 2, “name” : “张三”, “age” : 24 }
{ “_id” : 3, “name” : “王五”, “age” : 25 }
{ “_id” : 4, “name” : “李四”, “age” : 26 }
{ “_id” : 5, “name” : “赵六”, “age” : “27岁” }

db.user.find({age:{%0A%E6%88%96%E8%80%85%0Adb.user.find(%7Bage%3A%7B#card=math&code=type%3A2%7D%7D%29%0A%E6%88%96%E8%80%85%0Adb.user.find%28%7Bage%3A%7B)type:’string’}})

db.user.find({age:{$type:’string’}})
{ “_id” : 5, “name” : “赵六”, “age” : “27岁” }

## 4.6 limit与skip
这里结合使用limit和skip方法可以达到关系型数据库的分析效果。
limit(n) 只查询前n条数据，如果不指定n，查询所有文档。
![image-20200805065546767](assets/image-20200805065546767.png)
skip(m)跳过前m个文档，如果不指定m，默认为0
![image-20200805065715411](assets/image-20200805065715411.png)
## 4.7 排序
在 MongoDB 中使用 sort() 方法对数据进行排序，sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，**其中 1 为升序排列，而 -1 是用于降序排列**。
如果将sort()，skip()，limit()一起执行的时候，先执行sort()再执行skip()再执行limit()。
按照_id倒序排序，跳过第一个，查询3条数据。

db.user.find().limit(3).skip(1).sort({_id:-1})

![image-20200805070451845](assets/image-20200805070451845.png)
**组合排序**

db.user.find().limit(3).sort({age:-1,_id:1})

db.user.find().limit(3).sort({_id:1,age:-1})

![image-20200805072043001](assets/image-20200805072043001.png)
我们看到是可以组合排序的，先根据前面的排序，如果后面的排序字段相等，则按照后面指定的排序规则排序。
## 3.8 索引
索引实现原理【https://www.cnblogs.com/coder2012/p/5309197.html】
MongoDB中当然也是支持索引的，来提高查询效率，如果不使用索引，会扫描整个文档来找到满足查询条件的记录。

db.collection.createIndex({keys},{options})

如果keys里面指定多项，就是**复合索引**了（类似于Mysql的复合索引）。比如：

db.collection.createIndex( { “字段名1” : 排序方式, “字段名2” : 排序方式 },options)

key对应的值如果指定1则按升序创建索引，如果-1降序创建索引。
如果是**全文索引**，key值为“text"，如db.user.createIndex({"desp":"text"})。一个集合仅支持最多一个Text Index，中文分词不理想 推荐ES。只支持string类型。

db.collection.createIndex({“field”: “text”})

全文索引语法

db.collection.find({search:”searchWord”}})
db.user.find({search:”two”}})

如果属性值为数组，，MongoDB支持针对数组中每一个element创建索引，支持strings，numbers和nested documents。叫做**多键索引**。
针对地理空间坐标数据创建索引，叫做**地理空间索引**。`2dsphere`索引，用于存储和查找球面上的点；`2d`索引，用于存储和查找平面上的点。我们在地理空间位置上创建索引，应该使用2dsphere。一个平面坐标应该使用2d。
查询地理位置详情可以查看官方文档。

db.company.insert(
{
loc : { type: “Point”, coordinates: [ 116.482451, 39.914176 ] },
name: “大望路地铁”,
category : “Parks”
}
)
db.company.createIndex( { loc : “2dsphere” } )

参数不是1或-1，为2dsphere 或者 2d。还可以建立组合索引。

查询以[116.482451,39.914176]五公里内的坐标

db.company.find({
“loc” : {
“center”:[[116.482451,39.914176],0.05]
}
}
})

**哈希索引 Hashed Index**针对属性的哈希值进行索引查询，当要使用Hashed index时，MongoDB能够自动的计算hash值，无 需程序计算hash值。注：hash index仅支持等于查询，不支持范围查询。只能在单个字段建立哈希索引。

db.collection.createIndex({“field”: “hashed”})

options可选参数：
| Parameter          | Type          | Description                                                  |
| :----------------- | :------------ | :----------------------------------------------------------- |
| background         | Boolean       | "background" 默认值为**false**，建索引过程会阻塞其它数据库操作。，background可指定以后台方式创建索引，设为true，在后台建立索引的时候，不能对建立索引的collection进行一些坏灭型的操作，如：运行`repairDatabase，drop，compat,当你在建立索引的时候运行这些操作的会报错。` |
| unique             | Boolean       | 建立的索引是否唯一。指定为true创建唯一索引。默认值为**false**. |
| name               | string        | 索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成一个索引名称。 |
| dropDups           | Boolean       | **3.0+版本已废弃。**在建立唯一索引时是否删除重复记录,指定 true 创建唯一索引。默认值为 **false**. |
| sparse             | Boolean       | 对文档中不存在的字段数据不启用索引；这个参数需要特别注意，如果设置为true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 **false**. 可以在复合索引开启稀疏索引。 |
| expireAfterSeconds | integer       | 指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间。 |
| v                  | index version | 索引的版本号。默认的索引版本取决于mongod创建索引时运行的版本。 |
| weights            | document      | 索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得分权重。 |
| default_language   | string        | 对于文本索引，该参数决定了停用词及词干和词器的规则的列表。 默认为英语 |
| language_override  | string        | 对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language，默认值为 language. |
1、查看集合索引

db.col.getIndexes()

2、查看集合索引大小

db.col.totalIndexSize()

3、删除集合所有索引

db.col.dropIndexes()

_id的索引是不会删除的。
4、删除集合指定索引

db.col.dropIndex(“索引名称”)

利用 TTL 集合对存储的数据进行失效时间设置：经过指定的时间段后或在指定的时间点过期，MongoDB 独立线程去清除数据。类似于设置定时自动删除任务，可以清除历史记录或日志等前提条件，设置 Index 的关键字段为日期类型 new Date()。
**例如数据记录中 createDate 为日期类型时：**
-  设置时间180秒后自动清除。
-  设置在创建记录后，180 秒左右删除。

db.col.createIndex({“createDate”: 1},{expireAfterSeconds: 180})

**由记录中设定日期点清除。**
设置 A 记录在 2019 年 1 月 22 日晚上 11 点左右删除，A 记录中需添加 "c_date": new Date('Jan 22, 2019 23:00:00')，且 Index中expireAfterSeconds 设值为 0。其实也可以设置为任意字段名,只要为日期格式就可以。

db.col.createIndex({“c_date”: 1},{expireAfterSeconds: 0})

其他注意事项:
-  索引关键字段必须是 Date 类型。
-  非立即执行：扫描 Document 过期数据并删除是独立线程执行，默认 60s 扫描一次，删除也不一定是立即删除成功。
-  单字段索引，混合索引不支持。
其实对于MongoDB集群创建索引是有点麻烦的，参考文档：【https://www.imooc.com/article/291056?block_id=tuijian_wz】
在使用MongoDB时，在创建索引会涉及到在复制集(replication)以及分片(Shard)中创建，为了最大限度地减少构建索引的影响,在副本和分片中创建索引，使用滚动索引构建过程。如果不使用滚动索引构建过程：
- **主服务器上的前台索引构建需要数据库锁定。它复制为副本集辅助节点上的前台索引构建，并且复制工作程序采用全局数据库锁定，该锁定将读取和写入排序到索引服务器上的所有数据库。**
- **主要的后台索引构建复制为后台索引构建在辅助节点上。复制工作程序不会进行全局数据库锁定，并且辅助读取不会受到影响。**
- **对于主服务器上的前台和后台索引构建，副本集辅助节点上的索引操作在主节点完成构建索引之后开始。**
- **在辅助节点上构建索引所需的时间必须在oplog的窗口内，以便辅助节点可以赶上主节点。
  那么该如何创建呢？具体步骤呢?请看接下来的具体过程。**
**在副本集创建索引**
准备
  **必须在索引构建期间停止对集合的所有写入，否则可能会在副本集成员中获得不一致的数据。**
具体过程
在副本集中以滚动方式构建唯一索引包括以下过程：
①停止一个Secondary节点（从节点）并以单机模式重新启动，可以使用配置文件更新配置以单机模式重新启动：
- 注释掉replication.replSetName选项。
- 将net.port更改为其他端口。将原始端口设置注释掉。
- 在setParameter部分中将参数disableLogicalSessionCacheRefresh设置为true。
②创建索引：在单机模式下进行索引创建
③重新开启Replica Set 模式：索引构建完成后，关闭mongod实例。撤消作为独立启动时所做的配置 更改，以返回其原始配置并作为副本集的成员重新启动。
④在其他从节点中重复1、2、3步骤的过程操作。
⑤主节点创建索引，当所有从节点都有新索引时，降低主节点，使用上述过程作为单机模式重新启动它，并在原主节点上构建索引：
使用mongo shell中的rs.stepDown（）方法来降低主节点为从节点，
成功降级后，当前主节点成为从节点，副本集成员选择新主节点，并进行从节点创建方式进行创建索引。
**在分片集群创建唯一索引**
创建唯一索引，必须在索引构建期间停止对集合的所有写入。 否则，您可能会在副本集成员中获得不一致的数据。如果无法停止对集合的所有写入，请不要使用以下过程来创建唯一索引。
具体过程
①停止Balancer：将mongo shell连接到分片群集中的mongos实例，然后运行sh.stopBalancer（）以禁用Balancer。如果正在进行迁移，系统将在停止平衡器之前完成正在进行的迁移。
②确定Collection的分布：刷新该mongos的缓存路由表，以避免返回该Collection旧的分发信息。刷新后，对要构建索引的集合运行db.collection.getShardDistribution()。
③在包含集合Chunks的分片创建索引
    C1.停止从节点，并以单机模式重新启动：对于受影响的分片，停止从节点与其中一个分区相关联的mongod进    程，进行配置文件/命令模式更新后重新启动。
    配置文件：
        将net.port更改为其他端口。 注释到原始端口设置。
        注释掉replication.replSetName选项。
        注释掉sharding.clusterRole选项。
        在setParameter部分中将参数skipShardingConfigurationChecks设置为true。
        在setParameter部分中将参数disableLogicalSessionCacheRefresh设置为true。
    C2.创建索引：直接连接到在新端口上作为独立运行的mongod实例，并为此实例创建新索引。
    C3.恢复C1的配置，并作为 Replica Set成员启动：索引构建完成后，关闭mongod实例。 撤消作为单机模式时    所做的配置更改，以返回其原始配置并重新启动。
    C4.其他从节点分片重复C1、C2、C3过程创建索引。
    C5.主节点创建索引：当所有从节点都有新索引时，降低主节点，使用上述过程作为单机模式重新启动它，并在    原主节点上构建索引
    使用mongo shell中的rs.stepDown（）方法来降低主节点为从节点，成功降级后，当前主节点成为从节点，副    本集成员选择新主节点，并进行从节点创建方式进行创建索引。
    在其他受影响的分片重复C步骤;
    重启Balancer，一旦全部分片创建完索引，重启Balancer：sh.startBalancer()。
## 3.9 聚合
**单目聚合操作**
count()和distinct()
db.collection.find().count();
db.collection.count(query)
db.collection.distinct(fieldName,query,options)
官方文档：【https://docs.mongodb.com/manual/reference/method/db.collection.distinct/】
比如有数据

var arr = [
{ “_id”: 1, “dept”: “A”, “item”: { “sku”: “111”, “color”: “red” }, “sizes”: [ “S”, “M” ] },
{ “_id”: 2, “dept”: “A”, “item”: { “sku”: “111”, “color”: “blue” }, “sizes”: [ “M”, “L” ] },
{ “_id”: 3, “dept”: “B”, “item”: { “sku”: “222”, “color”: “blue” }, “sizes”: “S” },
{ “_id”: 4, “dept”: “A”, “item”: { “sku”: “333”, “color”: “black” }, “sizes”: [ “S” ] }];
db.inventory.insertMany(arr);

db.inventory.distinct( “dept” )
[ “A”, “B” ]
db.inventory.distinct( “item.sku” )
[ “111”, “222”, “333” ]
db.inventory.distinct( “item.sku” ,{“dept”:”A”})
[ “111”, “333” ]

**聚合管道**
语法：

db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

集合中的数据如下：

var array = [{
title: ‘MongoDB Overview’,
description: ‘MongoDB is no sql database’,
by_user: ‘runoob.com’,
url: ‘http://www.runoob1.com‘,
tags: [‘mongodb’, ‘database’, ‘NoSQL’],
likes: 100
},
{
title: ‘NoSQL Overview’,
description: ‘No sql database is very fast’,
by_user: ‘runoob.com’,
url: ‘http://www.runoob2.com‘,
tags: [‘mongodb’, ‘database’, ‘NoSQL’],
likes: 10
},
{
title: ‘Neo4j Overview’,
description: ‘Neo4j is no sql database’,
by_user: ‘Neo4j’,
url: ‘http://www.neo4j.com‘,
tags: [‘neo4j’, ‘database’, ‘NoSQL’],
likes: 750
}]

| 表达式    | 描述                                           | 实例                                                         |
| :-------- | :--------------------------------------------- | :----------------------------------------------------------- |
| $sum      | 计算总和。                                     | db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : "$likes"}}}])<br>结果<br>{ "_id" : "Neo4j", "num_tutorial" : 750 }<br/>{ "_id" : "runoob.com", "num_tutorial" : 110 } |
| $avg      | 计算平均值                                     | db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$avg : "$likes"}}}])<br>结果<br>{ "_id" : "runoob.com", "num_tutorial" : 55 }<br/>{ "_id" : "Neo4j", "num_tutorial" : 750 } |
| $min      | 获取集合中所有文档对应值得最小值。             | db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$min : "$likes"}}}])<br>结果<br>{ "_id" : "runoob.com", "num_tutorial" : 10 }<br/>{ "_id" : "Neo4j", "num_tutorial" : 750 } |
| $max      | 获取集合中所有文档对应值得最大值。             | db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$max : "$likes"}}}])<br>结果<br>{ "_id" : "Neo4j", "num_tutorial" : 750 }<br/>{ "_id" : "runoob.com", "num_tutorial" : 100 } |
| $push     | 在结果文档中插入值到一个数组中。               | db.mycol.aggregate([{$group : {_id : "$by_user", url : {$push: "$url"}}}])<br>结果<br>`{ "_id" : "Neo4j", "url" : [ "http://www.neo4j.com" ] }{ "_id" : "runoob.com", "url" : [ "http://www.runoob2.com", "http://www.runoob1.com" ] }` |
| $addToSet | 在结果文档中插入值到一个数组中，但不创建副本。 | db.mycol.aggregate([{$group : {_id : "$by_user", url : {$addToSet: "$url"}}}])<br>结果<br>`{ "_id" : "Neo4j", "url" : [ "http://www.neo4j.com" ] }{ "_id" : "runoob.com", "url" : [ "http://www.runoob2.com", "http://www.runoob1.com" ] }` |
| $first    | 根据资源文档的排序获取第一个文档数据。         | db.mycol.aggregate([{$group : {_id : "$by_user", first_url : {$first : "$url"}}}])<br>结果<br>`{ "_id" : "Neo4j", "first_url" : "http://www.neo4j.com" }{ "_id" : "runoob.com", "first_url" : "http://www.runoob1.com" }` |
| $last     | 根据资源文档的排序获取最后一个文档数据         | db.mycol.aggregate([{$group : {_id : "$by_user", last_url : {$last : "$url"},likes:{$push:'$likes'}}}])<br>结果<br>`{ "_id" : "Neo4j", "last_url" : "http://www.neo4j.com", "likes" : [ 750 ] }{ "_id" : "runoob.com", "last_url" : "http://www.runoob2.com", "likes" : [ 100, 10 ] }` |

group 多个字段
db.mycol.aggregate([{title”,g2:”$by_user”}}}])
相当于sql select title as g1,by_user as g2 from mycol group by g1,g2

如果不需要进行分组 但是想计算 sum,avg,min,max 可以指定$group的_id为null
比如：

db.mycol.aggregate([{sum : “%0A%7B%20%22_id%22%20%3A%20null%2C%20%22likeSum%22%20%3A%20860%20%7D%0Adb.mycol.aggregate(%5B%7B#card=math&code=likes%22%7D%7D%7D%5D%29%0A%7B%20%22_id%22%20%3A%20null%2C%20%22likeSum%22%20%3A%20860%20%7D%0Adb.mycol.aggregate%28%5B%7B)group : {_id : null, likemin : {likes”}}}])
{ “_id” : null, “likemin” : 10 }

当然还有一个分组函数：参考文档【https://www.jianshu.com/p/206f036bdfc5】
db.collection.group({ key, reduce, initial [, keyf] [, cond] [, finalize] })
前三个是必备参数，“[]”中是可选参数
参数说明：
key
可以放用来分组的字段，并且会返回其中字段(group by 后面的字段)
reduce
是在分组操作期间对文档进行操作的聚合函数。可以返回总和或计数。该函数有两个参数：当前文档；该组的聚合结果文档。
initial
对结果中文档，字段进行初始化
cond
对数据筛选的条件，相当于where

管道的概念
管道在Unix和Linux中一般用于将当前命令的输出结果作为下一个命令的参数。

MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。

表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。

这里我们介绍一下聚合框架中常用的几个操作：

match：用于过滤数据，只输出符合条件的文档。limit：用来限制MongoDB聚合管道返回的文档数。
unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。
sort：将输入文档排序后输出。
$geoNear：输出接近某一地理位置的有序文档。

$match

db.mycol.aggregate([{$match:{by_user:”Neo4j”}}])
结果：

db.mycol.aggregate([{$match:{by_user:”Neo4j”}}]).pretty()
{
“_id” : ObjectId(“5f2a131f6e9504b5b351f1da”),
“title” : “Neo4j Overview”,
“description” : “Neo4j is no sql database”,
“by_user” : “Neo4j”,
“url” : “http://www.neo4j.com“,
“tags” : [
“neo4j”,
“database”,
“NoSQL”
],
“likes” : 750
}

$project 可以隐藏字段，指定显示字段

db.article.aggregate(
{ $project : {
title : 1 ,
author : 1 ,
}}
);

这样的话结果中就只还有_id,tilte和author三个字段了，默认情况下_id字段是被包含的，如果要想不包含_id话可以这样:

db.article.aggregate(
{ $project : {
_id : 0 ,
title : 1 ,
author : 1
}});

数据
![image-20201005155549447](assets/image-20201005155549447.png)
```ja
db.student.aggregate([{$group:{_id:"$school",avg_age:{$avg: "$age"}}},{$match:{avg_age:{$gte:20}}}])

先根据school进行分组求平均年龄，然后过滤平均年龄大于20的数据，然后将avg_age命名为avgAge

db.student.aggregate([{$group:{_id:"$school",avg_age:{$avg: "$age"}}},{$match:{avg_age:{$gte:20}}},{$project: {avgAge:"$avg_age"}},])

3.10 MapReduce

官方文档：【https://docs.mongodb.com/manual/reference/method/db.collection.mapReduce/】

Pipeline查询速度快于MapReduce，但是MapReduce的强大之处在于能够在多台Server上并行执行复 杂的聚合逻辑。MongoDB不允许Pipeline的单个聚合操作占用过多的系统内存，如果一个聚合操作消 耗20%以上的内存，那么MongoDB直接停止操作，并向客户端输出错误消息。

MapReduce是一种计算模型，简单的说就是将大批量的工作（数据）分解（MAP）执行，然后再将结 果合并成最终结果（REDUCE）。

>db.collection.mapReduce(
function() {emit(key,value);}, //map 函数 key是用来分组的。values用来
function(key,values) {return reduceFunction}, //reduce 函数
{
out: collection,
query: document,
sort: document,
limit: number,
finalize: <function>,
verbose: <boolean>
}
)

MapReduce是一种计算模型，简单的说就是将大批量的工作（数据）分解（MAP）执行，然后再将结 果合并成最终结果（REDUCE）。

参数说明：

• map：是JavaScript 函数，负责将每一个输入文档转换为零或多个文档，生成键值对序列,作为 reduce 函数参数
• reduce：是JavaScript 函数，对map操作的输出做合并的化简的操作（将key-value变成keyvalues，也就是把values数组变成一个单一的值value）
• out：统计结果存放集合
• query： 一个筛选条件，只有满足条件的文档才会调用map函数。
• sort： 和limit结合的sort排序参数（也是在发往map函数前给文档排序），可以优化分组机制
• limit： 发往map函数的文档数量的上限（要是没有limit，单独使用sort的用处不大）
• finalize：可以对reduce输出结果再一次修改
• verbose：是否包括结果信息中的时间信息，默认为fasle

其实执行完MapReduce之后，会以out指定的名字创建一个集合。

> show collections;
majorAvgAge
student
>

然后 db.majorAvgAge.find()

数据：

db.student.mapReduce(function(){emit(this.major,this.age)},
function(key,values){return Array.avg(values)},
{
    out:"majorAvgAge"
})

db.student.mapReduce(function(){emit(this.major,this.age)},
function(key,values){return Array.avg(values)},
{
    out:"majorAvgAge",
    finalize:function(key,value){
        return value+3;
    }
})

db.student.mapReduce(function(){emit(this.major,this.age)},
function(key,values){return Array.avg(values)},
{
    out:"majorAvgAge",
    query:{school:"武汉纺织大学"},
    finalize:function(key,value){
        return value+3;
    }
})

5 高级

5.1 执行计划

我们利用js循环插入100万条数据来模拟大批量数据。

for(let i=1;i<=1000000;i++){
    db.test_employee.insert({id:i,name:"test_"+i,salary:(Math.random()*20000).toFixed(2)})
}

explain()也接收不同的参数，通过设置不同参数我们可以查看更详细的查询计划。

• queryPlanner：queryPlanner是默认参数，具体执行计划信息参考下面的表格。
• executionStats：executionStats会返回执行计划的一些统计信息(有些版本中和 allPlansExecution等同)。
• allPlansExecution：allPlansExecution用来获取所有执行计划，结果参数基本与上文相同。

db.collection.find({}).explain()
db.collection.find({}).explain("queryPlanner")

explain响应信息解析：

对queryPlanner分析

queryPlanner : queryPlanner 的返回

• queryPlanner.plannerVersion：查询计划版本

• queryPlanner.namespace : 该值返回的是该query所查询的表

• queryPlanner.indexFilterSet : 针对该query是否有indexfilter

• queryPlanner.winningPlan : 查询优化器针对该query所返回的最优执行计划的详细内容。

• queryPlanner.winningPlan.stage : 最优执行计划的stage，这里返回是FETCH，可以理解为通过返回的index位置去检索具体的文档（stage有数个模式，将在后文中进行详解）。

• queryPlanner.winningPlan.inputStage : 用来描述子stage，并且为其父stage提供文档和索引关键字。

• queryPlanner.winningPlan.stage的child stage，此处是IXSCAN，表示进行的是index scanning。

• queryPlanner.winningPlan.keyPattern : 所扫描的index内容，此处是did : 1,status : 1,modify_time : -1与scid : 1

• queryPlanner.winningPlan.indexName：winning plan所选用的index。

• queryPlanner.winningPlan.isMultiKey是否是Multikey，此处返回是false，如果索引建立在array上，此处将是true。

• queryPlanner.winningPlan.direction：此query的查询顺序，此处是forward，如果用了.sort({modify_time : -1})将显示backward。

• queryPlanner.winningPlan.indexBounds : winningplan所扫描的索引范围,如果没有制定范围就是[MaxKey, MinKey]，这主要是直接定位到mongodb的chunck中去查找数据，加快数据读取。

• queryPlanner.rejectedPlans：其他执行计划（非最优而被查询优化器reject的）的详细返回，其中具体信息与winningPlan的返回中意义相同，故不在此赘述。

对 executionStats 返回逐层分析

第一层，executionTimeMillis

最为直观 explain 返回值是 executionTimeMillis 值，指的是我们这条语句的执行时间，这个值当然是希望越少越好。
其中有3个 executionTimeMillis，分别是：

• executionStats.executionTimeMillis
  该query的整体查询时间。

• executionStats.executionStages.executionTimeMillisEstimate
  该查询根据index去检索document获得2001条数据的时间。

• executionStats.executionStages.inputStage.executionTimeMillisEstimate
  该查询扫描2001行index所用时间。

第二层，index 与 document 扫描数与查询返回条目数

这个主要讨论3个返回项：nReturned、totalKeysExamined、totalDocsExamined，分别代表该条查询返回的条目、索引扫描条目、文档扫描条目。这些都是直观地影响到 executionTimeMillis，我们需要扫描的越少速度越快。
对于一个查询，我们最理想的状态是：

nReturned = totalKeysExamined = totalDocsExamined

第三层，stage状态分析

那么又是什么影响到了 totalKeysExamined 和 totalDocsExamined ？是 stage 的类型。类型列举如下：

• COLLSCAN：全表扫描
• IXSCAN：索引扫描
• FETCH：根据索引去检索指定document
• SHARD_MERGE：将各个分片返回数据进行merge
• SORT：表明在内存中进行了排序
• LIMIT：使用limit限制返回数
• SKIP：使用skip进行跳过
• IDHACK：针对_id进行查询
• HARDING_FILTER：通过mongos对分片数据进行查询
• COUNT：利用db.coll.explain().count()之类进行count运算
• COUNTSCAN：count不使用Index进行count时的stage返回
• COUNT_SCAN：count使用了Index进行count时的stage返回
• SUBPLA：未使用到索引的$or查询的stage返回
• TEXT：使用全文索引进行查询时候的stage返回
• PROJECTION：限定返回字段时候stage的返回

对于普通查询，我希望看到 stage 的组合(查询的时候尽可能用上索引)：

• Fetch+IDHACK
• Fetch+ixscan
• Limit+（Fetch+ixscan）
• PROJECTION+ixscan
• SHARDING_FITER+ixscan
• COUNT_SCAN

不希望看到包含如下的 stage：

• COLLSCAN(全表扫描)
• SORT(使用sort但是无index)
• 不合理的SKIP
• SUBPLA(未用到index的$or)
• COUNTSCAN(不使用index进行count)

执行以下命令：

db.test_employee.find({id:{$gt:500000}}).sort({id:-1}).limit(100).explain("executionStats")

返回：

{
    "queryPlanner" : {
        "plannerVersion" : 1,
        "namespace" : "lagou_learn.test_employee",
        "indexFilterSet" : false,
        "parsedQuery" : {
            "id" : {
                "$gt" : 500000
            }
        },
        "winningPlan" : {
            "stage" : "LIMIT",
            "limitAmount" : 100,
            "inputStage" : {
                "stage" : "FETCH",
                "inputStage" : {
                    "stage" : "IXSCAN",
                    "keyPattern" : {
                        "id" : 1
                    },
                    "indexName" : "id_1",
                    "isMultiKey" : false,
                    "multiKeyPaths" : {
                        "id" : [ ]
                    },
                    "isUnique" : false,
                    "isSparse" : false,
                    "isPartial" : false,
                    "indexVersion" : 2,
                    "direction" : "backward",
                    "indexBounds" : {
                        "id" : [
                            "[inf.0, 500000.0)"
                        ]
                    }
                }
            }
        },
        "rejectedPlans" : [ ]
    },
    "executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 100,
        "executionTimeMillis" : 0,
        "totalKeysExamined" : 100,
        "totalDocsExamined" : 100,
        "executionStages" : {
            "stage" : "LIMIT",
            "nReturned" : 100,
            "executionTimeMillisEstimate" : 0,
            "works" : 101,
            "advanced" : 100,
            "needTime" : 0,
            "needYield" : 0,
            "saveState" : 0,
            "restoreState" : 0,
            "isEOF" : 1,
            "limitAmount" : 100,
            "inputStage" : {
                "stage" : "FETCH",
                "nReturned" : 100,
                "executionTimeMillisEstimate" : 0,
                "works" : 100,
                "advanced" : 100,
                "needTime" : 0,
                "needYield" : 0,
                "saveState" : 0,
                "restoreState" : 0,
                "isEOF" : 0,
                "docsExamined" : 100,
                "alreadyHasObj" : 0,
                "inputStage" : {
                    "stage" : "IXSCAN",
                    "nReturned" : 100,
                    "executionTimeMillisEstimate" : 0,
                    "works" : 100,
                    "advanced" : 100,
                    "needTime" : 0,
                    "needYield" : 0,
                    "saveState" : 0,
                    "restoreState" : 0,
                    "isEOF" : 0,
                    "keyPattern" : {
                        "id" : 1
                    },
                    "indexName" : "id_1",
                    "isMultiKey" : false,
                    "multiKeyPaths" : {
                        "id" : [ ]
                    },
                    "isUnique" : false,
                    "isSparse" : false,
                    "isPartial" : false,
                    "indexVersion" : 2,
                    "direction" : "backward",
                    "indexBounds" : {
                        "id" : [
                            "[inf.0, 500000.0)"
                        ]
                    },
                    "keysExamined" : 100,
                    "seeks" : 1,
                    "dupsTested" : 0,
                    "dupsDropped" : 0
                }
            }
        }
    },
    "serverInfo" : {
        "host" : "8477691e110c",
        "port" : 12017,
        "version" : "4.4.1",
        "gitVersion" : "ad91a93a5a31e175f5cbf8c69561e788bbc55ce1"
    },
    "ok" : 1
}

5.2 慢查询

• 开启内置的查询分析器,记录读写操作效率 db.setProfilingLevel(n,m) n的取值可选0,1,2

  • 0表示不记录
  • 1表示记录慢速操作,如果值为1,m必须赋值单位为ms,用于定义慢速查询时间的阈值
  • 2表示记录所有的读写操作

• 2.查询监控结果 db.system.profile.find().sort({millis:-1}).limit(3)

• 3.分析慢速查询 应用程序设计不合理、不正确的数据模型、硬件配置问题,缺少索引等

• 4.解读explain结果 确定是否缺少索引

// 1
{
    "op": "query",
    "ns": "first.test_employee",
    "command": {
        "find": "test_employee",
        "filter": {
            "salary": {
                "$in": [
                    "1253.74",
                    "6750.84"
                ]
            }
        },
        "lsid": {
            "id": UUID("05a83af1-44e2-4152-9d7f-8b84db1451fb")
        },
        "$db": "first"
    },
    "keysExamined": NumberInt("0"),
    "docsExamined": NumberInt("100000"),
    "cursorExhausted": true,
    "numYield": NumberInt("781"),
    "nreturned": NumberInt("2"),
    "queryHash": "CD2B9A1D",
    "planCacheKey": "CD2B9A1D",
    "locks": {
        "ParallelBatchWriterMode": {
            "acquireCount": {
                "r": NumberLong("1")
            }
        },
        "ReplicationStateTransition": {
            "acquireCount": {
                "w": NumberLong("783")
            }
        },
        "Global": {
            "acquireCount": {
                "r": NumberLong("783")
            }
        },
        "Database": {
            "acquireCount": {
                "r": NumberLong("782")
            }
        },
        "Collection": {
            "acquireCount": {
                "r": NumberLong("782")
            }
        },
        "Mutex": {
            "acquireCount": {
                "r": NumberLong("1")
            }
        }
    },
    "flowControl": { },
    "storage": { },
    "responseLength": NumberInt("228"),
    "protocol": "op_msg",
    "millis": NumberInt("115"),
    "planSummary": "COLLSCAN",
    "execStats": {
        "stage": "COLLSCAN",
        "filter": {
            "salary": {
                "$in": [
                    "1253.74",
                    "6750.84"
                ]
            }
        },
        "nReturned": NumberInt("2"),
        "executionTimeMillisEstimate": NumberInt("1"),
        "works": NumberInt("100002"),
        "advanced": NumberInt("2"),
        "needTime": NumberInt("99999"),
        "needYield": NumberInt("0"),
        "saveState": NumberInt("781"),
        "restoreState": NumberInt("781"),
        "isEOF": NumberInt("1"),
        "direction": "forward",
        "docsExamined": NumberInt("100000")
    },
    "ts": ISODate("2021-04-10T14:43:38.217Z"),
    "client": "127.0.0.1",
    "appName": "MongoDB Shell",
    "allUsers": [ ],
    "user": ""
}
// 2
{
    "op": "query",
    "ns": "first.test_employee",
    "command": {
        "find": "test_employee",
        "filter": {
            "salary": {
                "$in": [
                    "1253.74",
                    "6750.84"
                ]
            }
        },
        "lsid": {
            "id": UUID("05a83af1-44e2-4152-9d7f-8b84db1451fb")
        },
        "$db": "first"
    },
    "keysExamined": NumberInt("0"),
    "docsExamined": NumberInt("100000"),
    "cursorExhausted": true,
    "numYield": NumberInt("781"),
    "nreturned": NumberInt("2"),
    "queryHash": "CD2B9A1D",
    "planCacheKey": "CD2B9A1D",
    "locks": {
        "ParallelBatchWriterMode": {
            "acquireCount": {
                "r": NumberLong("1")
            }
        },
        "ReplicationStateTransition": {
            "acquireCount": {
                "w": NumberLong("783")
            }
        },
        "Global": {
            "acquireCount": {
                "r": NumberLong("783")
            }
        },
        "Database": {
            "acquireCount": {
                "r": NumberLong("782")
            }
        },
        "Collection": {
            "acquireCount": {
                "r": NumberLong("782")
            }
        },
        "Mutex": {
            "acquireCount": {
                "r": NumberLong("1")
            }
        }
    },
    "flowControl": { },
    "storage": { },
    "responseLength": NumberInt("228"),
    "protocol": "op_msg",
    "millis": NumberInt("113"),
    "planSummary": "COLLSCAN",
    "execStats": {
        "stage": "COLLSCAN",
        "filter": {
            "salary": {
                "$in": [
                    "1253.74",
                    "6750.84"
                ]
            }
        },
        "nReturned": NumberInt("2"),
        "executionTimeMillisEstimate": NumberInt("3"),
        "works": NumberInt("100002"),
        "advanced": NumberInt("2"),
        "needTime": NumberInt("99999"),
        "needYield": NumberInt("0"),
        "saveState": NumberInt("781"),
        "restoreState": NumberInt("781"),
        "isEOF": NumberInt("1"),
        "direction": "forward",
        "docsExamined": NumberInt("100000")
    },
    "ts": ISODate("2021-04-10T14:43:18.045Z"),
    "client": "127.0.0.1",
    "appName": "MongoDB Shell",
    "allUsers": [ ],
    "user": ""
}