MongoDB上机实验

最新推荐文章于 2024-04-06 11:21:30 发布

Q拾光～

最新推荐文章于 2024-04-06 11:21:30 发布

阅读量3.1k

点赞数 5

分类专栏： MongoDB

本文链接：https://blog.csdn.net/qq_40629792/article/details/85259105

版权

MongoDB 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

MongoDB安装与启动

一、安装MongoDB

(1) 创建自己的安装路径，D:\NDBMS\MongoDB

(2) 在D:\NDBMS\MongoDB下解压下载的zip文件，然后在D:\NDBMS\MongoDB下新建data文件夹D:\NDBMS\MongoDB\data

(3) 在data文件夹下再分别建立db，log两个文件夹，至此mongodb下有以下文件夹

D:\NDBMS\MongoDB\bin

D:\NDBMS\MongoDB\data\db

D:\NDBMS\MongoDB\data\log

在log文件夹下创建一个日志文件MongoDB.log，即D:\NDBMS\MongoDB\data\log\MongoDB.log

为了方便启动mongodb程序，将mongod.exe路径加入环境变量，在环境变量path里加入路径：D:\NDBMS\MongoDB\bin 。这样在命令行任何地方都能用到mongod命令。

二、启动MongoDB服务

MongoDB安装好以后，启动MongoDB服务有2种方式，一种是通过控制台手动方式启动，另一种是通过操作系统自动方式启动。

(一) 控制台手动方式启动

(1) 打开命令行程序输入以下命令：

D:\NDBMS\MongoDB\bin>mongod -dbpath "D:\NDBMS\MongoDB\data\db"

如果配置了path环境变量可以直接输入命令行：

mongod -dbpath "D:\NDBMS\MongoDB\data"

或者：

D:\NDBMS\MongoDB\bin>mongod --dbpath "D://NDBMS//MongoDB//data"

--logpath"D://NDBMS//MongoDB//data//log//MongoDB.log" –logappend

注：mongod --dbpath 命令是创建数据库文件的存放位置，启动mongodb服务时需要先确定数据库文件存放的位置，否则系统不会自动创建，启动会不成功。

　　 mongod --logpath 表示日志文件存放的路径。

mongod --logappend 表示以追加的方式写日志文件。

注意：在这种启动方式下，该控制台服务程序不能关闭，如果关闭该程序，MongoDB服务就会立即停止，因此，以这种方式启动MongoDB服务，每次启动MongoDB程序前都要按上述步骤做相同的操作。如果是64位的MongoDB，其默认的端口号是27017；如果是32位的MongoDB，其默认的端口号是28017。用户也可以通过--port命令来修改端口，如：mongod --port 9888 "d:\\mongodb\\data\\db"

MongoDB服务启动以后，用户可以在浏览器的URL中输入http://127.0.0.1:27017/网址或者直接输入http://localhost:27017就可在浏览器中查看到64位的MongoDB已经启动的信息：如下所示：

(2) 用户在路径D:\NDBMS\MongoDB\bin下直接双击mongo.exe，这样mongoDB就启动了。

(二) 操作系统自动方式启动

配置本地Windows mongodb 服务。通过该步骤操作，不需要每次启动MongoDB程序前手动启动服务，而是通过设置MongoDB，将MongoDB配置为开机自动启动服务，也可在配置后每次通过命令行net start MongoDB 启动服务。

(1)在D:\NDBMS\MongoDB路径下新建配置文件mongo.config，在该配置文件中输入以下命令，保存即可。

dbpath=D:\NDBMS\MongoDB\data\db

logpath=D:\NDBMS\MongoDB\data\log\MongoDB.log

(2)用管理员身份打开控制台程序cmd。

(3)配置Windows服务。

先切换到 D:\NDBMS\MongoDB\bin目录下。

输入以下命令行：

mongod –config "D:\NDBMS\Mongodb\mongo.config" --install --serviceName "MongoDB"

这时就可在Windows的服务程序中看到服务名称是MongoDB服务了，表示在操作系统下已经完成对MongoDB服务的配置。

接下来就可以在Windows的服务程序中设置启动方式：自动启动或手动启动。

也可在控制台下手动方式启动MongoDB服务，命令是：NET START MongoDB。

也可在控制台下手动方式停止MongoDB服务，命令行：NET STOP MongoDB。

(4)用户在路径D:\NDBMS\MongoDB\bin下直接双击mongo.exe，这样mongoDB就启动了。

实验一：

1、先删除demo库中col集合中原有数据：>db.remove({})
2、插入以下数据：
db.col.insert([{title: 'MongoDB 教程',
description: 'MongoDB 是Nosql 数据库的代表之一',
by: 'Turing',
url: 'http://www.baidu.com',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 100},
{title: 'MongoDB 教程',
description: '本书讲解了MongoDB的基本概念与实际操作，MongoDB是一种 Nosql 数据库',
by: [{first:'Obama'},{second:'Tom'}],
url: 'http://www.zzti.edu.cn',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 200},
{title: 'MongoDB 数据库开发基础实践',
description: '这是一本学习MongoDB数据库开发的基础教材',
by: 'Smith',
url: 'http://www.tinghua.edu.cn',
tags: ['mongodb', 'database', 'NoSQL'],
likes:300},
{title: 'MongoDB 实践与应用',
description: '这是一本关于MongoDB数据库的深入与浅出的书籍',
by: 'Trump',
url: 'http://www.tinghua.edu.cn',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 400},
{title: 'MongoDB 高级编程',
description: '这是一本MongoDB高级编程的书籍，适合于有一定基础的读者阅读',
by:[{first:'Obama'},{second:'Trump'}],
url: 'http://www.sohu.com',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 500}
])

实验一、MongoDB数据库的安装、启动、创建数据库及帮助等基本命令的使用。
实验二、聚合函数aggregate()的使用。按照给出的demo数据库分别使用$match、$group、$project、$limit、$sort、$skip和$unwind这七个聚合运算符进行以下操作。
(1)在demo库中col集合中，要求以书名title分组，求每种书的册数。
(2)在demo库中col集合中，要求按照书籍的标题(title)进行分组，计算每种书的册数，并求字段likes的平均值。
(3)在demo库中对col集合中，按照书籍的标题(title)进行分组，计算每种书的册数，平均likes值。
(4)在demo库中对col集合中，查询字段likes值大于50的document。
(5)$match和$group应用。在demo库中的对col集合中，查询likes大于50且按title分组统计各组书籍的册数。
(6)$match、$group和$project应用。在demo库中对col集合中，查询likes大于50 ，且按书籍名称title分组，统计各组书籍的册数，并显示投影为counter字段，也显示统计后的书名投影。
(7)$match、$group、$project和$sort应用。在demo库中对col集合中，查询likes小于600 且按书籍名称title分组，统计各组书籍的册数，并显示投影为counter字段，也显示统计后的书名投影，结果要按照_id升序排序。
(8)$match、$group、$project和$sort应用。在demo库中对col集合中，查询likes大于50 且按书籍名称title分组，统计各组书籍的册数，并显示投影为counter字段，也显示统计后的书名投影，结果要按照_id升序排序，限制输出3条查询结果，并跳过第1条记录。
(9)$unwind应用。在demo库中对col集合中by字段进行拆分。by中数据的格式为：by:[{first:'Obama'},{second:'Trump'}]。

MongoDB shell version: 3.2.20-18-gbfcb5e357a
connecting to: test
> show dbs
demo   0.000GB
local  0.000GB
test   0.000GB
> use demo
switched to db demo
> show collections
col
> db.col.remove({})
WriteResult({ "nRemoved" : 5 })
> db.col.insert([{title: 'MongoDB 教程', 
...                                  description: 'MongoDB 是Nosql 数据库的代表之一',
...                                  by: 'Turing',
...                                  url: 'http://www.baidu.com',
...                                  tags: ['mongodb', 'database', 'NoSQL'],
...                                  likes: 100},
...                                {title: 'MongoDB 教程', 
...                                description: '本书讲解了MongoDB的基本概念与实际操作，MongoDB是一种 Nosql                                description: '本书讲解了MongoDB的基本概念与实际操作，MongoDB是一种 Nosql 数据库',
...                                  by: [{first:'Obama'},{second:'Tom'}],
...                                  url: 'http://www.zzti.edu.cn',
...                                  tags: ['mongodb', 'database', 'NoSQL'],
...                                  likes: 200},
...                                 {title: 'MongoDB 数据库开发基础实践', 
...                                  description: '这是一本学习MongoDB数据库开发的基础教材',
...                                  by: 'Smith',
...                                  url: 'http://www.tinghua.edu.cn',
...                                  tags: ['mongodb', 'database', 'NoSQL'],
...                                  likes:300},
...                                 {title: 'MongoDB 实践与应用', 
...                                  description: '这是一本关于MongoDB数据库的深入与浅出的书籍',
...                                  by: 'Trump',
...                                  url: 'http://www.tinghua.edu.cn',
...                                  tags: ['mongodb', 'database', 'NoSQL'],
...                                  likes: 400},
...                                 {title: 'MongoDB 高级编程', 
...                                   description: '这是一本MongoDB高级编程的书籍，适合于有一定基础的读者阅                                  description: '这是一本MongoDB高级编程的书籍，适合于有一定基础的读者阅读',
...                                   by:[{first:'Obama'},{second:'Trump'}],
...                                   url: 'http://www.sohu.com',
...                                   tags: ['mongodb', 'database', 'NoSQL'],
...                                   likes: 500}
...  
...                              ])
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 5,
        "nUpserted" : 0,
        "nMatched" : 0,
        "nModified" : 0,
        "nRemoved" : 0,
        "upserted" : [ ]
})
> db.col.find().pretty()
{
        "_id" : ObjectId("5c2f3b0a1ccd330c0f551383"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是Nosql 数据库的代表之一",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}
{
        "_id" : ObjectId("5c2f3b0a1ccd330c0f551384"),
        "title" : "MongoDB 教程",
        "description" : "本书讲解了MongoDB的基本概念与实际操作，MongoDB是一种 Nosql 数据库",
        "by" : [
                {
                        "first" : "Obama"
                },
                {
                        "second" : "Tom"
                }
        ],
        "url" : "http://www.zzti.edu.cn",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 200
}
{
        "_id" : ObjectId("5c2f3b0a1ccd330c0f551385"),
        "title" : "MongoDB 数据库开发基础实践",
        "description" : "这是一本学习MongoDB数据库开发的基础教材",
        "by" : "Smith",
        "url" : "http://www.tinghua.edu.cn",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 300
}
{
        "_id" : ObjectId("5c2f3b0a1ccd330c0f551386"),
        "title" : "MongoDB 实践与应用",
        "description" : "这是一本关于MongoDB数据库的深入与浅出的书籍",
        "by" : "Trump",
        "url" : "http://www.tinghua.edu.cn",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 400
}
{
        "_id" : ObjectId("5c2f3b0a1ccd330c0f551387"),
        "title" : "MongoDB 高级编程",
        "description" : "这是一本MongoDB高级编程的书籍，适合于有一定基础的读者阅读",
        "by" : [
                {
                        "first" : "Obama"
                },
                {
                        "second" : "Trump"
                }
        ],
        "url" : "http://www.sohu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 500
}
> db.col.find({likes:{$gt:50}})
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551383"), "title" : "MongoDB 教程", "description" : "MongoDB 是Nosql 数据库的代表 之一", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 100 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551384"), "title" : "MongoDB 教程", "description" : "本书讲解了MongoDB的基本概念与实际操作，MongoDB是一种 Nosql 数据库", "by" : [ { "first" : "Obama" }, { "second" : "Tom" } ], "url" : "http://www.zzti.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 200 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551385"), "title" : "MongoDB 数据库开发基础实践", "description" : "这是一本学习MongoDB数据库开发的基础教材", "by" : "Smith", "url" : "http://www.tinghua.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 300 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551386"), "title" : "MongoDB 实践与应用", "description" : "这是一本关于MongoDB数据库的深入与浅出的书籍", "by" : "Trump", "url" : "http://www.tinghua.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 400 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551387"), "title" : "MongoDB 高级编程", "description" : "这是一本MongoDB高级编程的书籍，适合于有一定基础的读者阅读", "by" : [ { "first" : "Obama" }, { "second" : "Trump" } ], "url" : "http://www.sohu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 500 }
> db.col.find({likes:{$lt:600}})
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551383"), "title" : "MongoDB 教程", "description" : "MongoDB 是Nosql 数据库的代表 之一", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 100 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551384"), "title" : "MongoDB 教程", "description" : "本书讲解了MongoDB的基本概念与实际操作，MongoDB是一种 Nosql 数据库", "by" : [ { "first" : "Obama" }, { "second" : "Tom" } ], "url" : "http://www.zzti.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 200 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551385"), "title" : "MongoDB 数据库开发基础实践", "description" : "这是一本学习MongoDB数据库开发的基础教材", "by" : "Smith", "url" : "http://www.tinghua.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 300 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551386"), "title" : "MongoDB 实践与应用", "description" : "这是一本关于MongoDB数据库的深入与浅出的书籍", "by" : "Trump", "url" : "http://www.tinghua.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 400 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551387"), "title" : "MongoDB 高级编程", "description" : "这是一本MongoDB高级编程的书籍，适合于有一定基础的读者阅读", "by" : [ { "first" : "Obama" }, { "second" : "Trump" } ], "url" : "http://www.sohu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 500 }
> db.col.find().sort({_id:1}).limit(3)
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551383"), "title" : "MongoDB 教程", "description" : "MongoDB 是Nosql 数据库的代表 之一", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 100 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551384"), "title" : "MongoDB 教程", "description" : "本书讲解了MongoDB的基本概念与实际操作，MongoDB是一种 Nosql 数据库", "by" : [ { "first" : "Obama" }, { "second" : "Tom" } ], "url" : "http://www.zzti.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 200 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551385"), "title" : "MongoDB 数据库开发基础实践", "description" : "这是一本学习MongoDB数据库开发的基础教材", "by" : "Smith", "url" : "http://www.tinghua.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 300 }
> db.col.find().sort({_id:1}).limit(3).skip(1)
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551384"), "title" : "MongoDB 教程", "description" : "本书讲解了MongoDB的基本概念与实际操作，MongoDB是一种 Nosql 数据库", "by" : [ { "first" : "Obama" }, { "second" : "Tom" } ], "url" : "http://www.zzti.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 200 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551385"), "title" : "MongoDB 数据库开发基础实践", "description" : "这是一本学习MongoDB数据库开发的基础教材", "by" : "Smith", "url" : "http://www.tinghua.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 300 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551386"), "title" : "MongoDB 实践与应用", "description" : "这是一本关于MongoDB数据库的深入与浅出的书籍", "by" : "Trump", "url" : "http://www.tinghua.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 400 }
> db.col.find().sort({_id:1}).skip(1).limit(3)
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551384"), "title" : "MongoDB 教程", "description" : "本书讲解了MongoDB的基本概念与实际操作，MongoDB是一种 Nosql 数据库", "by" : [ { "first" : "Obama" }, { "second" : "Tom" } ], "url" : "http://www.zzti.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 200 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551385"), "title" : "MongoDB 数据库开发基础实践", "description" : "这是一本学习MongoDB数据库开发的基础教材", "by" : "Smith", "url" : "http://www.tinghua.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 300 }
{ "_id" : ObjectId("5c2f3b0a1ccd330c0f551386"), "title" : "MongoDB 实践与应用", "description" : "这是一本关于MongoDB数据库的深入与浅出的书籍", "by" : "Trump", "url" : "http://www.tinghua.edu.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 400 }
>

实验二、MongoDB数据库的基本操作。

创建数据库：>show dbs ; >use soft
创建集合：>show collections >db.createCollection(“col”)
创建带参数的集合：先查看帮助。带有几个关键参数的 createCollection() 的用法。
插入文档： >db.col.insert({ title: 'MongoDB 教程',
description: 'MongoDB 是Nosql 数据库的代表之一',
by: 'Turing',
url: 'http://www.baidu.com',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 100,
press:[{publish1:"TsingHua"},{publish2:"HEducation"}, {publish:"ElectricPress"}
]
})
(1)插入文档
直接插入一个文档：
>db.collection.insert({field_1:value_1,...,field_n:value_n})
使用数组，数组的每个元素都是一个文档，下面的例子中，将k个文档都插入到集合中。
>db.collection.insert([{field_11:value_11,...,field_1n:value_1n},
...
{field_k1:value_k1,...,field_kn:value_kn}
])
将一个变量表示的文档插入到集合中：
>var temp={"a":1,"b":2,"c":3}
>db.collection.insert(temp)
以上插入数据的形式都可以使用insertMany()函数或者save()函数实现。

（2）删除数据库文档
使用remove()函数删除查询指定的文档：
>db.collection.remove(<query>) 或者
>db.collection.remove(var)
使用deleteOne()函数删除查询指定的一个文档：
>db.collection.deleteOne(<query>) 或者
>db.collection.deleteOne(var)
使用deleteMany()函数删除查询的多个文档：
>db.collection.deleteMany(<query>) 或者
>db.collection.deleteMany(var)

(3)删除集合： >db.col.drop()
删除数据库：>db; >db.dropDatabase()
(4)$set修改器操作
进行$set修改器和$unset修改器操作，注意upsert和multi参数的使用。
update()方法用于更新文档。
语法格式如下：
db. collection_name.update(
<query>,
<update>,
{
upsert: <boolean>,
multi : <boolean>,
writeConcern: <document>
}
)
以上参数说明：
query : update前的数据查询过滤，类似于SQL语言中update语句的where子句。
update : update的对象和一些更新的操作符（如$set,$inc...）等，也可以理解为SQL语言中update语句的set子句。
upsert : 备选参数，如果不存在update的集合数据，是否插入该数据,true为插入该数据，默认是false，不插入该数据。
multi : 备选参数，默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来的多个集合全部更新。
writeConcern :备选参数，抛出异常的级别。

1、只更新第一条记录。查询字段值likes等于400，然后将字段by的值修改为Turing。
2、只更新第一条记录。查询字段值likes等于400，然后将字段by的值修改为Turing。
3、如果没有查到文档，也不做插入操作，如果查到文档就更新全部文档。将数据库中字段likes值大于400的都修改为450，操作要求：如果数据库中没有该文档，不插入该文档；如果查询到多个文档就更新全部文档。
4、如果没有查询到文档，就做插入操作，如果查到文档只更新第一个文档。查询字段值likes大于400的文档，然后将字段by的值修改为Tom。
5、如果没有查到文档，也不做插入操作，如果查到文档只更新第一个文档。
6、如果没有查到文档，就做插入操作；如果查询到多个文档就更新全部文档。
7、删除文档中的一个字段url。

实验二
> show dbs
demo   0.000GB
local  0.000GB
test   0.000GB
> use soft
switched to db soft
> show collections
> db.createCollection("col")
{ "ok" : 1 }
> db.col.insert({  title: 'MongoDB 教程',
...                         description: 'MongoDB 是Nosql 数据库的代表之一',
...                         by: 'abc',
...                         url: 'http://www.baidu.com',
...                         tags: ['mongodb', 'database', 'NoSQL'],
...                         likes: 100,
...                         press:[{publish1:"TsingHua"},{publish2:"HEducation"},                                             press:[{publish1:"TsingHua"},{publish2:"HEducation"},                               {publish:"ElectricPress"}
...                               ]
...                         })
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c2f3ee91ccd330c0f551388"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是Nosql 数据库的代表之一",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100,
        "press" : [
                {
                        "publish1" : "TsingHua"
                },
                {
                        "publish2" : "HEducation"
                },
                {
                        "publish" : "ElectricPress"
                }
        ]
}
> var temp={"a":1,"b":2,"c":3}
> db.col.insert(temp)
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c2f3ee91ccd330c0f551388"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是Nosql 数据库的代表之一",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100,
        "press" : [
                {
                        "publish1" : "TsingHua"
                },
                {
                        "publish2" : "HEducation"
                },
                {
                        "publish" : "ElectricPress"
                }
        ]
}
{ "_id" : ObjectId("5c2f3fb41ccd330c0f551389"), "a" : 1, "b" : 2, "c" : 3 }
> db.col.remove(temp)
WriteResult({ "nRemoved" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c2f3ee91ccd330c0f551388"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是Nosql 数据库的代表之一",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100,
        "press" : [
                {
                        "publish1" : "TsingHua"
                },
                {
                        "publish2" : "HEducation"
                },
                {
                        "publish" : "ElectricPress"
                }
        ]
}
> show collections
col
> db.col.drop()
true
> show collections
> show dbs
demo   0.000GB
local  0.000GB
test   0.000GB
> db.dropDatabase()
{ "dropped" : "demo", "ok" : 1 }
> show dbs
local  0.000GB
test   0.000GB
(1)>db.col.update({likes:400},{by:Turing}})
writeConcern: ({"nMatched":2,"nUpserted":0,"nModified":2})
(2)>db.col.update({likes:400},{by:Turing}})
writeConcern:({"nMatched":2,"nUpserted":0,"nModified":2})
（3）>db.col.find({title: 'MongoDB 教程',description: 'MongoDB 是Nosql 数据库的代表之一',by: 'Turing', url: 'http://www.baidu.com',tags: ['mongodb','database','NoSQL'],likes:100,press:[{publish1:"TsingHua"},{publish2:"HEducation"})
>db.col.update({likes:450},false,true)
writeConcern: ({"nMatched":1,"nUpserted":0,"nModified":1})
（4）>db.col.find({title: 'MongoDB 教程',description: 'MongoDB 是Nosql 数据库的代表之一',by: 'Turing', url: 'http://www.baidu.com',tags: ['mongodb','database','NoSQL'],likes:100,press:[{publish1:"TsingHua"},{publish2:"HEducation"})
>db.col.update({likes:400}，{by:tom})
writeConcern: ({"nMatched":2,"nUpserted":0,"nModified":2})
(5)>db.col.find({title: 'MongoDB 教程',description: 'MongoDB 是Nosql 数据库的代表之一',by: 'Turing', url: 'http://www.baidu.com',tags: ['mongodb','database','NoSQL'],likes:100,press:[{publish1:"TsingHua"},{publish2:"HEducation"})
 >db.col.update({"count":{$gt:10}}，{&set:{"ok"}}，false，false})
（6）>db.col.find({title: 'MongoDB 教程',description: 'MongoDB 是Nosql 数据库的代表之一',by: 'Turing', url: 'http://www.baidu.com',tags: ['mongodb','database','NoSQL'],likes:100,press:[{publish1:"TsingHua"},{publish2:"HEducation"})
 >db.col.update({"count":{$gt:15}}，{&set:{"ok"}}，false，true})
(7)>db.col.remove({url})
WriteResult({"nRemoved":3})

实验三数组修改器

(一)数组修改器$push
$push操作符用于在指定的数组末尾添加一个数组元素。
$push操作符的语法格式是：
{ $push: { <field_1>: <value_1>, ...,<field_n>: <value_n> }}

修改器名   描述
$each   在数组字段中添加多个值。当与其它的修改器联合使用时，$each修改器不一定放在首要位置。
$slice   “切除”数组元素的数量，需要使用$each修改器。$sort   对数组元素排序，需要使用$each修改器。
$position   指定在数组插入新元素的位置。
{ $push: { <field_1>: { <modifier_1>: <value_1>, ...,<modifier_n>: <value_n> },
...
<field_n>: { <modifier_n1>: <value_n1>, ...,<modifier_nn>: <value_nn> }
}
}
实验1、在数组的最后添加一个数据。
(1)在集合col中插入如下文档，在该文档中有一个数组"成绩"。
>db.col.insert({
"姓名":"Tom",
"成绩":[{"语文":85},{"数学":90},{"英语":88},{"物理":86}]
})
(2)在指定为文档中添加数组元素。在数组"成绩"中添加文档{"化学":70}。
如果写成以下形式会产生什么结果？
>db.col.update({"姓名":"Tom"},
{$push: {"化学":70}}
)

> db.col.update({"姓名":"Tom"},{$push:{"成绩":{"化学":70}}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()                              70}}})
{
        "_id" : ObjectId("5c2f673d0a0792ccfa776ff8"),
        "姓名" : "Tom",
        "成绩" : [
                {
                        "语文" : 85
                },
                {
                        "数学" : 90
                },
                {
                        "英语" : 88
                },
                {
                        "物理" : 86
                },
                {
                        "化学" : 70
                }
        ],
        "化学" : [
                70
        ]
}

实验2、向数组中添加多个值。向数组中添加多个值需要使用带$each修改器的$push操作。
(1)向集合col中插入以下文档：
>db.col.insert({
"姓名":"Tom",
"成绩":[{"语文":85},{"数学":90},{"英语":88},{"物理":86}]
})
(2)在查询到的文档中，向字段名为"成绩"的数组中添加多个值，添加数据为：[{"历史":74},{"地理"：81},{"体育":91}]。

> db.col.update({"姓名":"Tom"},{$push:{"成绩":{$each:[{"历史":74},{"地理":81},{"体育":91}]}}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

实验3、带有多个修改器的$push操作。要求对查询结果按照"学期"降序排序，对$push后的结果进行$slice操作。
(1)在集合col中插入如下文档,在该文档中记录了学生Tom四个学期的语文、数学和外语成绩。
>db.col1.insert({
"姓名":"Tom",
"成绩":[{"学期":1,"语文":85,"数学":90,"英语":88},
{"学期":2,"语文":88,"数学":92,"英语":90},
{"学期":3,"语文":85,"数学":91,"英语":91},
{"学期":4,"语文":86,"数学":95,"英语":94}
]
})

(2)使用带$slice的$push运算对集合col1进行更新。用数组元素[{"学期":5,"语文":83,"数学":80,"英语":78},{"学期":6,"语文":83,"数学":82,"英语":91}]

> db.col1.update({"姓名":"Tom"},{$push:{"成绩":{$each:[{"学期":5,"语文":83,"数学":80,"英语":78},{"学期":6,"语文":83,"数 学":82,"英语":91}],$slice:-10,$sort:{"学期":-1} }}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

对文档进行更新，更新后按照降序排序，保留第6、5、4、3这四个学期的文档。
(二)数组修改器$addToSet
其语法格式是：
{ $addToSet: { <field_1>: <value_1>, ...,<field_n>: <value_n> } }
作为本小节的实验数据，先将以下文档插入到集合col中。
>db.col.insert({
title: 'MongoDB 教程',
description: 'MongoDB 是一个 Nosql 数据库',
by: 'Turing',
url: 'http://www.baidu.com',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 400
})
实验1、将一个键值对插入到指定数组。
将一个键值对{tags:"Data Structure"}插入到文档csd中的tags中，在tags字段的数组中没有元素"Data Structure"。

> db.col.update({"title":"MongoDB 教程"},{$push:{"tags":"Data Structure"}})

实验2、更新的键值对的键名在文档中不存，update语句中不写更新文档的字段，$addToSet操作符会创建一个数组字段，将插入的键值对名作为文档的字段名。
接上面例子，用键值对{"ip":"202.196.33.55"}对文档col进行更新。

> db.col.update({"title":"MongoDB 教程"},{$addToSet:{"ip":"202.196.33.55"}})

实验3、更新的键值对的键名在文档中有相应的字段名，但该字段不是数组类型。这种操作属于非法操作类型。
使用上面例子的数据，用键值对{"url":"202.196.33.55"}对文档col进行更新，在文档中存在字段url，但是该字段的值不是数组。

> db.col.update({"title":"MongoDB 教程"},{$addToSet:{"url":"202.196.33.55"}})

实验4、使用update语句更新文档的字段，$addToSet操作符添加的值在数组中已经存在，插入前数据库就会将已经存在的值过滤掉，只将那些数组中不存在的值插入到数组中。
使用上面例子的数据，按要求对文档进行更新。

> db.col.update({"title":"MongoDB 教程"},{$addToSet:{"tags":{$each:["mongodb","database","sql sever","java"]}}})

实验5、使用update语句对数组字段进行更新，以上面例子的数据为例，tags是数组类型的字段，要求用数据“"Operating System"," NoSQL ","Java Language"”对字段tags进行更新。
按要求对文档进行更新。

> db.col.update({"title":"MongoDB 教程"},{$addToSet:{"tags":{$each:["Operating System"," NoSQL","Java Language"]}}})

实验6、使用$push操作符也可以将指定的值添加到数组中。使用运算符$ne将指定的值"Operating System"添加到数组类型字段tags中。

> db.col.update({"title":"MongoDB 教程"},{$ne:{"tags":{$push:["Operating System"]}}})
WriteResult({
        "nMatched" : 0,
        "nUpserted" : 0,
        "nModified" : 0,
        "writeError" : {
                "code" : 9,
                "errmsg" : "Unknown modifier: $ne"
        }
})

(三)数组修改器$pop
$pop操作符语法格式为：
{ $pop: { <field_1>: <-1 | 1>, ...，<field_n>: <-1 | 1> } }
作为本小节的演示数据，先将以下文档插入到集合col中。
>db.col.insert({
title: 'MongoDB 教程',
description: 'MongoDB 是一个 Nosql 数据库',
by: 'Turing',
url: 'http://www.baidu.com',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 400
})
实验1、使用$pop操作符删除数组类型的字段tags中第一个数组元素。
>db.col.update({"by":"Turing"},{$pop:{"tags":-1}},false,false)

> db.col.update({"by":"Turing"},{$pop:{"tags":-1}},false,false)

(四) 数组修改器$pull
$pop操作符仅能删除指定数组字段中的第一个元素或者最后一个元素，如果要删除数组中所有的元素或者删除满足条件的数组中元素，就应使用操作符$pull.
操作符$pull的语法格式为：
{ $pull: { <field_1>: <value|condition>, ... ,<field2>: <value|condition> } }
作为本小节的演示数据，先将以下文档插入到集合col中。
>db.col.insert({
title: 'MongoDB 教程',
description: 'MongoDB 是一个 Nosql 数据库',
by: 'Turing',
url: 'http://www.baidu.com',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 400
})
实验1、使用$pull操作符对上述文档中数组字段tags进行更新操作，删除数组字段中元素值等于'database'的值。

> db.col.update({"by":"Turing"},{$pull:{"tags":"database"}})

实验2、使用$pull操作符对多个数组类型的字段进行update()操作。
(1)为了说明$pull同时对文档中的多个数组的操作，这里向集合col中插入以下2个文档：
>db.col.insert({"course" :["database","data structure","operating system"],
"address":["building_1 102","building_2 202","building_3 303"]
})
>db.col.insert({"course" :["MIS","data structure","java language"],
"address":["building_1 202","building_3 402","building_3 303"]
})
(2)要求集合col中所有的文档中、删除数组型字段course中的"data structure"和"MIS"的数组元素，同时删除数组型字段address中的"building_3 303"的数组元素。https://www.cnblogs.com/jayruan/p/7979699.html

> db.col.update({"by":"Turing"},{$pull:{{"course":["data structure","MIS"]}，{"address","building_3 303"}}})
2018-12-14T14:51:19.537+0800 E QUERY    [thread1] SyntaxError: invalid property id @(shell):1:38
> db.col.update({},{$pull:{$in:["data structure","MIS"]}，{"address":"building_3 303"}})
2018-12-14T15:00:55.341+0800 E QUERY    [thread1] SyntaxError: illegal character @(shell):1:54

实验3、使用$pull操作符删除满足算术运算符条件的全部数组元素。
(1)先在集合col中插入一个文档如下：
>db.col.insert({_id:1 ,"English":[50,56,60,67,79,80,85]})
(2)使用$pull操作删除字段English中，元素值小于等于60的数据元素

> db.col.update({_id:1},{$pull:{"English":{$lte:60}}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()                                }}})
{ "_id" : 1, "English" : [ 67, 79, 80, 85 ] }


$gt:大于 $lt:小于 $gte:大于或等于 $lte:小于或等于

实验4、文档数组是数组元素都是文档。要求使用$pull操作符删除文档数组中的数组元素。
(1)先将下列包含文档数组的文档插入到集合col中，可插入一个或者多个这样的文档。
>db.col.insert({ "姓名":"Tom",
"成绩":[ {"学期":1,"语文":85,"数学":90,"英语":88},
{"学期":2,"语文":88,"数学":92,"英语":90},
{"学期":3,"语文":85,"数学":91,"英语":91},
{"学期":4,"语文":86,"数学":95,"英语":94}
]
})
(2)将文档数组型字段"成绩"的元素值等于{ "学期":2 , "语文":88 }，这2个条件是与的关系，需要同时得到满足。
实验5、文档数组是数组元素都是文档，由文档组成的数组元素中又包含数组，要求使用$pull操作符删除文档数组元素中的数组元素。
(1)先将下列包含文档数组的文档插入到集合col中，可插入一个或者多个这样的文档。
> db.col.insert({ "姓名":"Tom",
"成绩":[ {"学期":1,score:[ {"语文":85,"数学":90,"英语":88}] },
{"学期":2,score:[ {"语文":88,"数学":92,"英语":90}] }
]
})
(2)使用$pull操作符对插入的文档进行更新，$pull操作符在内嵌文档的数组类型元素score上应用多个操作条件。

> db.col.update({},{$pull:{{"成绩":{score:{"英语":88,"数学":92}}}},{multi:true})

实验三
> use demo
switched to db demo
(一)
实验1.(1)
> db.col.insert({
...                    "姓名":"Tom",
...                    "成绩":[{"语文":85},{"数学":90},{"英语":88},{"物理":86}]
...                  })
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c2f4c8d1ccd330c0f55138a"),
        "姓名" : "Tom",
        "成绩" : [
                {
                        "语文" : 85
                },
                {
                        "数学" : 90
                },
                {
                        "英语" : 88
                },
                {
                        "物理" : 86
                }
        ]
}
> db.col.update({"姓名":"Tom"},
...                  {$push: {"化学":70}}
...                 )
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()                                                                         )
{
        "_id" : ObjectId("5c2f4e543bc91b6704432341"),
        "姓名" : "Tom",
        "成绩" : [
                {
                        "语文" : 85
                },
                {
                        "数学" : 90
                },
                {
                        "英语" : 88
                },
                {
                        "物理" : 86
                }，
	{
	        "化学" : 70
	}
        ]
}
(2)> db.col.update({"姓名":"Tom"},{$push:{"成绩":{"化学":70}}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()                              70}}})
{
        "_id" : ObjectId("5c2f673d0a0792ccfa776ff8"),
        "姓名" : "Tom",
        "成绩" : [
                {
                        "语文" : 85
                },
                {
                        "数学" : 90
                },
                {
                        "英语" : 88
                },
                {
                        "物理" : 86
                },
                {
                        "化学" : 70
                }
        ],
        "化学" : [
                70
        ]
}
实验2.(1)
> db.col.insert({
...                    "姓名":"Tom",
...                    "成绩":[{"语文":85},{"数学":90},{"英语":88},{"物理":86}]
...                  })
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c3040d0ee69d23a298e6bed"),
        "姓名" : "Tom",
        "成绩" : [
                {
                        "语文" : 85
                },
                {
                        "数学" : 90
                },
                {
                        "英语" : 88
                },
                {
                        "物理" : 86
                }
        ]
}
(2)> db.col.update({"姓名":"Tom"},{$push:{"成绩":{$each:[{"历史":74},{"地理":81},{"体育":91}]}}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()                                                   
{
        "_id" : ObjectId("5c3040d0ee69d23a298e6bed"),
        "姓名" : "Tom",
        "成绩" : [
                {
                        "语文" : 85
                },
                {
                        "数学" : 90
                },
                {
                        "英语" : 88
                },
                {
                        "物理" : 86
                },
                {
                        "历史" : 74
                },
                {
                        "地理" : 81
                },
                {
                        "体育" : 91
                }
        ]
}
实验3.(1)
> db.col1.insert({
...                    "姓名":"Tom",
...                    "成绩":[{"学期":1,"语文":85,"数学":90,"英语":88},
...                            {"学期":2,"语文":88,"数学":92,"英语":90},
...                            {"学期":3,"语文":85,"数学":91,"英语":91},
...                            {"学期":4,"语文":86,"数学":95,"英语":94}
...                           ]
...                     })
WriteResult({ "nInserted" : 1 })
> db.col1.find().pretty()
{
        "_id" : ObjectId("5c2f51303bc91b6704432343"),
        "姓名" : "Tom",
        "成绩" : [
                {
                        "学期" : 1,
                        "语文" : 85,
                        "数学" : 90,
                        "英语" : 88
                },
                {
                        "学期" : 2,
                        "语文" : 88,
                        "数学" : 92,
                        "英语" : 90
                },
                {
                        "学期" : 3,
                        "语文" : 85,
                        "数学" : 91,
                        "英语" : 91
                },
                {
                        "学期" : 4,
                        "语文" : 86,
                        "数学" : 95,
                        "英语" : 94
                }
        ]
}
（2）
> db.col1.update({"姓名":"Tom"},{$push:{"成绩":{$each:[{"学期":5,"语文":83,"数学":80,"英语":78},{"学期":6,"语文":83,"数 学":82,"英语":91}],$slice:-10,$sort:{"学期":-1} }}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col1.find().pretty()
{                           $sort:{"学期":-1} }}})})
        "_id" : ObjectId("5c2f51303bc91b6704432343"),
        "姓名" : "Tom",
        "成绩" : [
                {
                        "学期" : 6,
                        "语文" : 83,
                        "数学" : 82,
                        "英语" : 91
                },
                {
                        "学期" : 5,
                        "语文" : 83,
                        "数学" : 80,
                        "英语" : 78
                },
                {
                        "学期" : 4,
                        "语文" : 86,
                        "数学" : 95,
                        "英语" : 94
                },
                {
                        "学期" : 3,
                        "语文" : 85,
                        "数学" : 91,
                        "英语" : 91
                },
                {
                        "学期" : 2,
                        "语文" : 88,
                        "数学" : 92,
                        "英语" : 90
                },
                {
                        "学期" : 1,
                        "语文" : 85,
                        "数学" : 90,
                        "英语" : 88
                }
        ]
}
（二）
1.> db.col.drop()
true
> db.col.insert({
...     title: 'MongoDB 教程', 
...     description: 'MongoDB 是一个 Nosql 数据库',
...     by: 'Turing',
...     url: 'http://www.baidu.com',
...     tags: ['mongodb', 'database', 'NoSQL'],
...     likes: 400
...            })
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c304773ef2d340f46113495"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 400
}
> db.col.update({"title":"MongoDB 教程"},{$push:{"tags":"Data Structure"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()                                               })})
{
        "_id" : ObjectId("5c304773ef2d340f46113495"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL",
                "Data Structure"
        ],
        "likes" : 400
}
2.> db.col.update({"title":"MongoDB 教程"},{$addToSet:{"ip":"202.196.33.55"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()                                                  })
{
        "_id" : ObjectId("5c304773ef2d340f46113495"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL",
                "Data Structure"
        ],
        "likes" : 400,
        "ip" : [
                "202.196.33.55"
        ]
}
3.> db.col.update({"title":"MongoDB 教程"},{$addToSet:{"url":"202.196.33.55"}})
WriteResult({
        "nMatched" : 0,
        "nUpserted" : 0,
        "nModified" : 0,
        "writeError" : {
                "code" : 16837,
                "errmsg" : "Cannot apply $addToSet to a non-array field. Field named 'url' has a non-array type String in the document _id: ObjectId('5c304773ef2d340f46113495')"
        }
})
> db.col.find().pretty()                                                     })
{
        "_id" : ObjectId("5c304773ef2d340f46113495"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL",
                "Data Structure"
        ],
        "likes" : 400,
        "ip" : [
                "202.196.33.55"
        ]
}
4.> db.col.update({"title":"MongoDB 教程"},{$addToSet:{"tags":{$each:["mongodb","database","sql sever","java"]}}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()                                                                                      })
{
        "_id" : ObjectId("5c304773ef2d340f46113495"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL",
                "Data Structure",
                "sql sever",
                "java"
        ],
        "likes" : 400,
        "ip" : [
                "202.196.33.55"
        ]
}
5.> db.col.update({"title":"MongoDB 教程"},{$addToSet:{"tags":{$each:["Operating System"," NoSQL","Java Language"]}}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()                                                                                          })
{
        "_id" : ObjectId("5c304773ef2d340f46113495"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL",
                "Data Structure",
                "sql sever",
                "java",
                "Operating System",
                " NoSQL",
                "Java Language"
        ],
        "likes" : 400,
        "ip" : [
                "202.196.33.55"
        ]
}
6.> db.col.update({"title":"MongoDB 教程"},{$ne:{"tags":{$push:["Operating System"]}}})
WriteResult({
        "nMatched" : 0,
        "nUpserted" : 0,
        "nModified" : 0,
        "writeError" : {
                "code" : 9,
                "errmsg" : "Unknown modifier: $ne"
        }
})
(三)1.
> db.col.drop()
true
> db.col.insert({
...     title: 'MongoDB 教程', 
...     description: 'MongoDB 是一个 Nosql 数据库',
...     by: 'Turing',
...     url: 'http://www.baidu.com',
...     tags: ['mongodb', 'database', 'NoSQL'],
...     likes: 400
...            })
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c304f33ef2d340f46113496"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 400
}
> db.col.update({"by":"Turing"},{$pop:{"tags":-1}},false,false)
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c304f33ef2d340f46113496"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "database",
                "NoSQL"
        ],
        "likes" : 400
}
（四）
实验1> db.col.find().pretty()
{
        "_id" : ObjectId("5c304fa5ef2d340f46113497"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 400
}
> db.col.update({"by":"Turing"},{$pull:{"tags":"database"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c304fa5ef2d340f46113497"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "NoSQL"
        ],
        "likes" : 400
}
实验2（1）
> db.col.drop()
true
> db.col.insert({"course" :["database","data structure","operating system"],
...                  "address":["building_1 102","building_2 202","building_3 303"]
...                })
WriteResult({ "nInserted" : 1 })
> db.col.insert({"course" :["MIS","data structure","java language"],
...                  "address":["building_1 202","building_3 402","building_3 303"]
...                })
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c305138ef2d340f46113498"),
        "course" : [
                "database",
                "data structure",
                "operating system"
        ],
        "address" : [
                "building_1 102",
                "building_2 202",
                "building_3 303"
        ]
}
{
        "_id" : ObjectId("5c305141ef2d340f46113499"),
        "course" : [
                "MIS",
                "data structure",
                "java language"
        ],
        "address" : [
                "building_1 202",
                "building_3 402",
                "building_3 303"
        ]
}
(2)> db.col.update({"by":"Turing"},{$pull:{{"course":["data structure","MIS"]}，{"address","building_3 303"}}})
2018-12-14T14:51:19.537+0800 E QUERY    [thread1] SyntaxError: invalid property id @(shell):1:38
> db.col.update({},{$pull:{$in:["data structure","MIS"]}，{"address":"building_3 303"}})
2018-12-14T15:00:55.341+0800 E QUERY    [thread1] SyntaxError: illegal character @(shell):1:54
实验3（1）> db.col.drop()
true
> db.col.insert({_id:1 ,"English":[50,56,60,67,79,80,85]})
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{ "_id" : 1, "English" : [ 50, 56, 60, 67, 79, 80, 85 ] }
（2）> db.col.update({_id:1},{$pull:{"English":{$lte:60}}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()                                }}})
{ "_id" : 1, "English" : [ 67, 79, 80, 85 ] }
实验4（1）> db.col.drop()
true
> db.col.insert({  "姓名":"Tom",
...                   "成绩":[ {"学期":1,"语文":85,"数学":90,"英语":88},
...                           {"学期":2,"语文":88,"数学":92,"英语":90},
...                           {"学期":3,"语文":85,"数学":91,"英语":91},
...                           {"学期":4,"语文":86,"数学":95,"英语":94}
...                         ]
...                })
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c30594828fbaf8c27daf040"),
        "姓名" : "Tom",
        "成绩" : [
                {
                        "学期" : 1,
                        "语文" : 85,
                        "数学" : 90,
                        "英语" : 88
                },
                {
                        "学期" : 2,
                        "语文" : 88,
                        "数学" : 92,
                        "英语" : 90
                },
                {
                        "学期" : 3,
                        "语文" : 85,
                        "数学" : 91,
                        "英语" : 91
                },
                {
                        "学期" : 4,
                        "语文" : 86,
                        "数学" : 95,
                        "英语" : 94
                }
        ]
}
>
实验5
> db.col.drop()
true
> db.col.insert({  "姓名":"Tom",
...                   "成绩":[ {"学期":1,score:[ {"语文":85,"数学":90,"英语":88}] },
...                          {"学期":2,score:[ {"语文":88,"数学":92,"英语":90}] }
...                         ]
...               })
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c305d6b2edea9275e799d71"),
        "姓名" : "Tom",
        "成绩" : [
                {
                        "学期" : 1,
                        "score" : [
                                {
                                        "语文" : 85,
                                        "数学" : 90,
                                        "英语" : 88
                                }
                        ]
                },
                {
                        "学期" : 2,
                        "score" : [
                                {
                                        "语文" : 88,
                                        "数学" : 92,
                                        "英语" : 90
                                }
                        ]
                }
        ]
}
> db.col.update({},{$pull:{{"成绩":{score:{"英语":88,"数学":92}}}},{multi:true})

实验游标索引聚集函数

(一) $where操作符

作为例子使用的数据，先向集合col中插入以下2个文档，这两个文档中都有字段值相等的情况。

>db.col.insertMany([{"_id":1,

"姓名":"tom",

"语文":85,"数学":85,"英语":88},

{"_id":2,

"姓名":"smith",

"语文":85,"数学":91,"英语":91}

])

利用以上数据执行以下例子操作。

例1、使用$where运算符查询_id号等于1的文档。

例2、使用以上数据，使用$where操作符查询数据库中的两个文档中是否存在语文和数学相等的文档。

例3、使用$where进行查询，判断上面给出两个文档中有无两门成绩相等的情况。根据要求需要使用JavaScript语言的for/in循环语句，使用该循环语句对每一个文档分别进行处理，在处理的过程中需要将同一个文档分别保存在两个变量中，然后进行键值对判断，因此，这里需要使用双重for/in循环语句。

> db.col.find().pretty()
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
{ "_id" : 2, "姓名" : "smith", "语文" : 85, "数学" : 91, "英语" : 91 }
> db.col.find({"_id":1})
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
>db.col.find( {"$where": function() {
   return (this."_id"==1);
} } )
> db.col.find( {"$where": function() {
...         for(var current in this){
... for(var other in this){
...      if(current != other && this[current] == this[other]){
... return true;
...      }
... }
...          }
... }});
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
{ "_id" : 2, "姓名" : "smith", "语文" : 85, "数学" : 91, "英语" : 91 }
>

(二) count( )方法

带count()函数的查询，count()函数返回查询文档数。

db.col.find(...).count()

例1、查询集合col中的字段85值大于等于85的文档数。

> db.col.find().count()
2
>db.col.find({"_id":{$gte:85}})

(三) limit( )方法

find( )方法后可以跟limit( )方法，limit( )方法用于限制输出的记录数，limit( )方法的形式为：

limit(number)

参数number是一个数字类型，表示用户希望输出查询结果的前number条记录数。

将下列文档插入到集合col中，作为实验用数据，可将likes字段值稍做修改，每修改一次就插入到集合中。

>db.col.insert({

title: 'MongoDB 教程',

description: 'MongoDB 是一个 Nosql 数据库',

by: 'Turing',

url: 'http://www.baidu.com',

tags: ['mongodb', 'database', 'NoSQL'],

likes: 420

})

> db.col.find()
{ "_id" : ObjectId("5c3066a22edea9275e799d72"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
{ "_id" : ObjectId("5c306db62edea9275e799d73"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 340 }
{ "_id" : ObjectId("5c306dc92edea9275e799d74"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 420 }
{ "_id" : ObjectId("5c306ddb2edea9275e799d75"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 450 }
>

例5、在demo库中，查询col集合里by等于Turing，并且likes大于400的信息，要求只输出2条记录。

>  db.col.find({"by":"Turing","likes":{$gt:400}}).limit(2)
{ "_id" : ObjectId("5c3066a22edea9275e799d72"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
{ "_id" : ObjectId("5c306dc92edea9275e799d74"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 420 }

例6、查询集合col中的字段likes值大于等于400的文档数,要求仅返回查询到的前3个文档。

> db.col.find({"likes":{$gte:400}}).limit(3)
{ "_id" : ObjectId("5c3066a22edea9275e799d72"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
{ "_id" : ObjectId("5c306dc92edea9275e799d74"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 420 }
{ "_id" : ObjectId("5c306ddb2edea9275e799d75"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 450 }

例7、查询集合col中的字段likes值大于等于400的文档数,要求仅返回查询到的前2个文档,并按照字段likes的值降序排序。

> db.col.find({"likes":{$gte:400}}).limit(2).sort({"likes":-1})
{ "_id" : ObjectId("5c306ddb2edea9275e799d75"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 450 }
{ "_id" : ObjectId("5c3066a22edea9275e799d72"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
>

(四) skip( )方法

skip( )语法格式为：

>db.collection_name.find( ).skip(number)

在MongoDB中查询结果的记录号从1开始，并按_id号升序进行排序。skip( )方法也有一个数字类型的参数number作为跳过的记录数，该方法用于跳过查询结果中指定数量的记录数，所谓“跳过”就是不输出，number从查询结果中第一条记录算起。

>db.col.insert({

title: 'MongoDB 教程',

description: 'MongoDB 是一个 Nosql 数据库',

by: 'Turing',

url: 'http://www.baidu.com',

tags: ['mongodb', 'database', 'NoSQL'],

likes: 440

})

例6、在demo库中，查询col集合里by等于Turing，要求输出查询结果跳过id号小的前2条记录。

> db.col.find({"by":"Turing"}).skip(2)

(五) skip( )与limit()方法联合使用

语法格式如下：

>db.collection_name.find( ).skip(number_1).limit(number_2)

或者

>db.collection_name.find( ).limit(number_2).skip(number_1)

例7、在demo库中，查询col集合里Author等于Tomas，要求输出查询结果跳过id号小的前2条记录后，再输出剩余记录的前3条。

>db.col.find({"Author":"Tomas"}).skip(2).limit(3)

例8、查询集合col中的字段likes值大于等于400的文档数,要求按字段likes值降序排序，仅返回查询到的前1个文档。

>db.col.find({"likes":{$gte:400}}).sort({"likes":-1}).limit(1)

(六) sort( )方法

在 MongoDB 中使用 sort() 方法对数据进行排序，sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列。

语法：

sort()方法基本语法如下所示：

>db.COLLECTION_NAME.find().sort({KEY:1})

例8、在demo库中，查询col集合里的数据，要求输出查询结果按照ID号升序排序。

>db.col.find().sort({KEY:1}).pretty()

>db.col.find().sort({"ID":1})

当skip()、 limilt()和sort()三个函数放在一起执行的时候，执行的顺序是先 sort(), 然后是 skip()，最后是显示的 limit()。

>db.col.find()sort({KEY:1}).skip(2).limit(2)

例9、查询集合col中的字段likes值大于等于400的文档数,要求按字段likes值降序排序，限制输出查询到的前3个文档，并跳过前2个文档。

>db.col.find({"likes":{$gte:400}}).sort({"likes":-1}).skip(2).limit(3)

limit(n)、skip(n)与sort()三个函数没有书写顺序要求,但是，不论是什么书写顺序，MongoDB总是对查询到的数据集先执行sort()函数，然后执行skip(n)函数，最后执行limit()函数。

(七) 游标

作为例子使用的数据，先向集合col中插入以下2个文档，这两个文档中都有字段值相等的情况。

>db.col.insertMany([{"_id":1,

"姓名":"tom",

"语文":85,"数学":85,"英语":88},

{"_id":2,

"姓名":"smith",

"语文":85,"数学":91,"英语":91}

])

例1、使用游标查询并输出数据库中的所有文档。

方法一
> var cursor = db.col.find()
> while(cursor.hasNext()){
...     var obj = cursor.next();
...     printjson(obj);
... }
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
{ "_id" : 2, "姓名" : "smith", "语文" : 85, "数学" : 91, "英语" : 91 }
>
方法二
> var cursor = db.col.find()
> cursor.forEach(function(doc){printjson(doc);});
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
{ "_id" : 2, "姓名" : "smith", "语文" : 85, "数学" : 91, "英语" : 91 }
>

例2、使用游标操作将_id等于1的文档中，语文增加5分。

var cursor = db.col.find();
db.col.update({"_id":1},{"$inc":{"语文":+5}})
var obj = cursor.next();
printjson(obj);

(八) 索引

createIndex()方法基本语法格式如下所示：

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

语法中 Key 为用户创建的索引字段，参数options的值决定字段是按升序或者是按降序排序，1表示按升序创建索引，-1表示按降序创建索引。

例1、在demo库中，要求在col集合的title字段上按照升序建立索引。

> db.col.createIndex({"title":1})

例2、在demo库中，要求在col集合的title字段上按照升序建立索引，在description字段上按照降序建立索引。

> db.col.createIndex({"title":1},{"description":-1})

(九) 聚集函数(aggregate)

Aggregate提供了多种stage可供选择，match、sort、limit等。对于嵌套数据的处理可以在Aggregate中实现，减少在代码上的编写。

管道操作符的分类：

管道操作符可以分为三类：

1.Stage操作符。

2.表达式操作符,主要用于投影($project)操作符。

3.累加器，主要用于分组操作符($group)。

Aggregate是聚合方法，参数是数组，每个数组元素的就是一个stage，对数据进行处理，处理完流到下一个stage。

aggregate()方法的基本语法格式如下所示：

aggregate(operators,[options],callback)

operators参数是如表1所示的聚合运算符的数组，它允许你定义对数据执行什么汇总操作。options参数设置readPreference属性，它定义了从哪里读取数据。callback参数取err或者res。

> db.col.find()
{ "_id" : ObjectId("5c30825d2edea9275e799d79"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
{ "_id" : ObjectId("5c3082722edea9275e799d7a"), "title" : "java 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 340 }
{ "_id" : ObjectId("5c3082882edea9275e799d7b"), "title" : "php 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 380 }

例1、操作符$sum应用。在demo库中col集合中，要求以书名title分组，求每种书的册数。

> db.col.aggregate({"$group":{"_id":"$title","count":{"$sum":"$likes"}} })
{ "_id" : "php 教程", "count" : 380 }
{ "_id" : "java 教程", "count" : 340 }
{ "_id" : "MongoDB 教程", "count" : 440 }
>

以上实例中，_id是必须填写的唯一值得字段，并按照字段title进行分组，counter是计算每种书的册数后的输出名。满足一次_id值，$sum的值加1。该语句类似以下的SQL语句：

select title, count(*) from col group by title

例2、操作符$avg应用。在demo库中col集合中，要求按照书籍的标题(title)进行分组，计算每种书的册数，并求字段likes的平均值。

> db.col.aggregate({"$group":{"_id":"$title","count":{"$sum":"$likes"},"avg":{"$avg":"$likes"}} })
{ "_id" : "php 教程", "count" : 380, "avg" : 380 }
{ "_id" : "java 教程", "count" : 340, "avg" : 340 }
{ "_id" : "MongoDB 教程", "count" : 440, "avg" : 440 }
>

例3、操作符$avg应用。在demo库中对col集合中，按照书籍的标题(title)进行分组，计算每种书的册数，平均likes值。

例4、操作符$match应用。在demo库中对col集合中，查询字段likes值大于50的document。根据题意需要使用过滤谓词$match。

例5、操作符$match和$group应用。在demo库中的对col集合中，查询likes大于50且按title分组统计各组书籍的册数。

例6、操作符$match、$group和$project应用。在demo库中对col集合中，查询likes大于50 ，且按书籍名称title分组，统计各组书籍的册数，并显示投影为counter字段，也显示统计后的书名投影。

2018-12-28T15:04:06.360+0800 I CONTROL  [main] Hotfix KB2731284 or later update
is not installed, will zero-out data files
MongoDB shell version: 3.2.20-18-gbfcb5e357a
connecting to: test
> show dbs
local  0.000GB
> use soft
switched to db soft
> show collections
> db.createCollection("col")
{ "ok" : 1 }
> show collections
col
(一)1.> db.col.drop()
true
> db.col.insertMany([{"_id":1,
...
...               "姓名":"tom",
...
...               "语文":85,"数学":85,"英语":88},
...
...              {"_id":2,
...
...               "姓名":"smith",
...
...               "语文":85,"数学":91,"英语":91}
...
...               ])
{ "acknowledged" : true, "insertedIds" : [ 1, 2 ] }
> db.col.find().pretty()
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
{ "_id" : 2, "姓名" : "smith", "语文" : 85, "数学" : 91, "英语" : 91 }
> db.col.find({"_id":1})
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
>db.col.find( {"$where": function() {
   return (this."_id"==1);
} } )
> db.col.find( {"$where": function() {
...         for(var current in this){
... for(var other in this){
...      if(current != other && this[current] == this[other]){
... return true;
...      }
... }
...          }
... }});
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
{ "_id" : 2, "姓名" : "smith", "语文" : 85, "数学" : 91, "英语" : 91 }
>
(二)
> db.col.find().count()
2
>db.col.find({"_id":{$gte:85}})
(三)
> use demo
switched to db demo
> db.col.drop()
true
> db.col.insert({
...
...     title: 'MongoDB ',
...
...     description: 'MongoDB 是一个 Nosql 数据库',
...
...     by: 'Turing',
...
...     url: 'http://www.baidu.com',
...
...     tags: ['mongodb', 'database', 'NoSQL'],
...
...     likes: 340
...
...            })
WriteResult({ "nInserted" : 1 })
> db.col.find().pretty()
{
        "_id" : ObjectId("5c3066a22edea9275e799d72"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 440
}
> db.col.find().pretty()
{
        "_id" : ObjectId("5c3066a22edea9275e799d72"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Turing",
        "url" : "http://www.baidu.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 440
}
5.> db.col.find()
{ "_id" : ObjectId("5c3066a22edea9275e799d72"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
{ "_id" : ObjectId("5c306db62edea9275e799d73"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 340 }
{ "_id" : ObjectId("5c306dc92edea9275e799d74"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 420 }
{ "_id" : ObjectId("5c306ddb2edea9275e799d75"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 450 }
>
>  db.col.find({"by":"Turing","likes":{$gt:400}}).limit(2)
{ "_id" : ObjectId("5c3066a22edea9275e799d72"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
{ "_id" : ObjectId("5c306dc92edea9275e799d74"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 420 }
>
6.
> db.col.find({"likes":{$gte:400}}).limit(3)
{ "_id" : ObjectId("5c3066a22edea9275e799d72"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
{ "_id" : ObjectId("5c306dc92edea9275e799d74"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 420 }
{ "_id" : ObjectId("5c306ddb2edea9275e799d75"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 450 }
>
7.
> db.col.find({"likes":{$gte:400}}).limit(2).sort({"likes":-1})
{ "_id" : ObjectId("5c306ddb2edea9275e799d75"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 450 }
{ "_id" : ObjectId("5c3066a22edea9275e799d72"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
>
(四)
> db.col.find({"by":"Turing"}).skip(2)
{ "_id" : ObjectId("5c306dc92edea9275e799d74"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 420 }
{ "_id" : ObjectId("5c306ddb2edea9275e799d75"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 450 }
>
(五)
7.>db.col.find({"Author":"Tomas"}).skip(2).limit(3)
8.>db.col.find({"likes":{$gte:400}}).sort({"likes":-1}).limit(1)
(六)
>db.col.find().sort({"ID":1})
>db.col.find()sort({KEY:1}).skip(2).limit(2)
>db.col.find({"likes":{$gte:400}}).sort({"likes":-1}).skip(2).limit(3)
(七)
> db.col.drop()
true
> db.col.insertMany([{"_id":1,
...
...               "姓名":"tom",
...
...               "语文":85,"数学":85,"英语":88},
...
...              {"_id":2,
...
...               "姓名":"smith",
...
...               "语文":85,"数学":91,"英语":91}
...
...               ])
{ "acknowledged" : true, "insertedIds" : [ 1, 2 ] }
> db.col.find().pretty()
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
{ "_id" : 2, "姓名" : "smith", "语文" : 85, "数学" : 91, "英语" : 91 }
1.> var cursor = db.col.find()
cursor.forEach(function(doc){printjson(doc);});
> while(cursor.hasNext()){
...     var obj = cursor.next();
...     printjson(obj);
... }
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
{ "_id" : 2, "姓名" : "smith", "语文" : 85, "数学" : 91, "英语" : 91 }
>
> var cursor = db.col.find()
> cursor.forEach(function(doc){printjson(doc);});
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
{ "_id" : 2, "姓名" : "smith", "语文" : 85, "数学" : 91, "英语" : 91 }
>
2.
> var cursor = db.col.find();
> var obj = cursor.next();
> db.col.update({"_id":1},{"$inc":{"语文":+5}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> printjson(obj);
{ "_id" : 1, "姓名" : "tom", "语文" : 85, "数学" : 85, "英语" : 88 }
> db.col.find()
{ "_id" : 1, "姓名" : "tom", "语文" : 90, "数学" : 85, "英语" : 88 }
{ "_id" : 2, "姓名" : "smith", "语文" : 85, "数学" : 91, "英语" : 91 }
>
(八)
1.> db.col.find()
{ "_id" : ObjectId("5c307de62edea9275e799d76"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
{ "_id" : ObjectId("5c307e012edea9275e799d77"), "title" : "Java 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
{ "_id" : ObjectId("5c307e132edea9275e799d78"), "title" : "Php 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "Turing", "url" : "http://www.baidu.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 440 }
> db.col.createIndex({"title":1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
>
2.>db.col.createIndex({"title":1},{"description":-1})

(九)
1.> db.col.aggregate({"$group":{"_id":"$title","count":{"$sum":"$likes"}} })
{ "_id" : "php 教程", "count" : 380 }
{ "_id" : "java 教程", "count" : 340 }
{ "_id" : "MongoDB 教程", "count" : 440 }
>
2.> db.col.aggregate({"$group":{"_id":"$title","count":{"$sum":"$likes"},"avg":{"$avg":"$likes"}} })
{ "_id" : "php 教程", "count" : 380, "avg" : 380 }
{ "_id" : "java 教程", "count" : 340, "avg" : 340 }
{ "_id" : "MongoDB 教程", "count" : 440, "avg" : 440 }
>

aggregate() 方法

MongoDB中聚合的方法使用aggregate()。

语法

aggregate() 方法的基本语法格式如下所示：

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

实例

集合中的数据如下：

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'w3cschool.cn',
   url: 'http://www.w3cschool.cn',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
},
{
   _id: ObjectId(7df78ad8902d)
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'w3cschool.cn',
   url: 'http://www.w3cschool.cn',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
},
{
   _id: ObjectId(7df78ad8902e)
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
},

现在我们通过以上集合计算每个作者所写的文章数，使用aggregate()计算结果如下：

> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
{
   "result" : [
      {
         "_id" : "w3cschool.cn",
         "num_tutorial" : 2
      },
      {
         "_id" : "Neo4j",
         "num_tutorial" : 1
      }
   ],
   "ok" : 1
}
>

以上实例类似sql语句： select by_user, count(*) from mycol group by by_user

在上面的例子中，我们通过字段by_user字段对数据进行分组，并计算by_user字段相同值的总和。

下表展示了一些聚合的表达式:

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

Q拾光～

关注

5
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
MongoDB上机实验

MongoDB安装与启动一、安装MongoDB(1) 创建自己的安装路径，D:\NDBMS\MongoDB(2) 在D:\NDBMS\MongoDB下解压下载的zip文件，然后在D:\NDBMS\MongoDB下新建data文件夹D:\NDBMS\MongoDB\data(3) 在data文件夹下再分别建立db，log两个文件夹，至此mongodb下有以下文件夹 D:...
复制链接

扫一扫