MongoDB操作及其相关指令

﹏ヽ暗。殇╰゛Y 2022-01-20 07:17 313阅读 0赞

1 show dbs 显示所有数据的列表  
2 db 显示当前数据库对象或集合 查看所有数据库  
3 use 数据库名 连接到一个指定数据库 如果没有则创建并连接  
4 db.runoob.insert() 向 runoob 数据库插入一些数据  
5 db.dropDatabase() 删除当前数据库  
6 db.site.drop() 删除了 runoob 数据库中的集合site：  
7 db.col.insert/save(document) 向集合中插入文档 如果col不存

在则自动创建  
8 db.col.find() 查看已经插入的文档  
9 db.col.find().pretty() 漂亮的显示已经插入的文档  
10 db.col.update(\{‘title’:‘MongoDB 教程’\},db.col.remove

(\{‘title’:‘MongoDB 教程’\})\{$set:\{‘title’:‘MongoDB’\}\}) 可以

看到标题(title)由原来的 “MongoDB 教程” 更新为了 “MongoDB”。  
以上语句只会修改第一条发现的文档，如果你要修改多条相同的文档

，则需要设置 multi 参数为 true。

> db.col.update(\{‘title’:‘MongoDB 教程’\},\{$set:

\{‘title’:‘MongoDB’\}\},\{multi:true\})  
11 db.col.remove(\{‘title’:‘MongoDB 教程’\})  
12 db.col.find(\{“by”:“菜鸟教程”\}).pretty() 相当于SQL中的

db.col.find(\{“by”:“菜鸟教程”\}).pretty()  
13 db.col.find(\{“by”:“菜鸟教程”, “title”:"MongoDB 教

程"\}).pretty() 通过by和title键来查询菜鸟教程中MongoDB 教程

的数据  
14 db.col.find(\{$or:\[\{“by”:“菜鸟教程”\},\{“title”: "MongoDB 教

程"\}\]\}).pretty() 查询键by值为 菜鸟教程 或键title值为MongoDB

教程的文档  
15 常规 SQL 语句为：'where likes>50 AND (by = ‘菜鸟教程’ OR

title = ‘MongoDB 教程’)’ db.col.find(\{“likes”: \{$gt:50\},

$or: \[\{“by”: “菜鸟教程”\},\{“title”: "MongoDB 教

程"\}\]\}).pretty()  
16 db.col.find(\{\},\{“title”:1,\_id:0\}).limit(2) MongoDB中读

取指定数量的数据记录，可以使用MongoDB的Limit方法，limit()方

法接受一个数字参数，该参数指定从MongoDB中读取的记录条数。  
17 db.col.find(\{\},\{“title”:1,\_id:0\}).limit(1).skip(1)  
使用limit()方法来读取指定数量的数据外，还可以使用skip()方法

来跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的

记录条数。  
18  
1 10  
2 20  
3 30  
Jump=(page-1)  
Db.col.find().pretty().limit(10).skip(jump)  
19 在MongoDB中使用使用sort()方法对数据进行排序，sort()方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。  
db.col.find(\{\},\{“title”:1,\_id:0\}).sort(\{“likes”:-1\})  
20 db.col.count()

一、NoSQL简介  
NoSQL(NoSQL = Not Only SQL )，意即"不仅仅是SQL"。  
在现代的计算系统上每天网络上都会产生庞大的数据量。  
这些数据有很大一部分是由关系数据库管理系统（RDMBSs）来处理。 1970年 E.F.Codd’s提出的关系模型的论文 “A relational model of data for large shared data banks”，这使得数据建模和应用程序编程更加简单。  
通过应用实践证明，关系模型是非常适合于客户服务器编程，远远超出预期的利益，今天它是结构化数据存储在网络和商务应用的主导技术。  
NoSQL 是一项全新的数据库革命性运动，早期就有人提出，发展至2009年趋势越发高涨。NoSQL的拥护者们提倡运用非关系型的数据存储，相对于铺天盖地的关系型数据库运用，这一概念无疑是一种全新的思维的注入。  
1、关系型数据库遵循ACID规则  
事务在英文中是transaction，和现实世界中的交易很类似，它有如下四个特性：  
（1）A (Atomicity) 原子性  
原子性很容易理解，也就是说事务里的所有操作要么全部做完，要么都不做，事务成功的条件是事务里的所有操作都成功，只要有一个操作失败，整个事务就失败，需要回滚。  
比如银行转账，从A账户转100元至B账户，分为两个步骤：1）从A账户取100元；2）存入100元至B账户。这两步要么一起完成，要么一起不完成，如果只完成第一步，第二步失败，钱会莫名其妙少了100元。  
（2）C (Consistency) 一致性  
一致性也比较容易理解，也就是说数据库要一直处于一致的状态，事务的运行不会改变数据库原本的一致性约束。  
例如现有完整性约束a+b=10，如果一个事务改变了a，那么必须得改变b，使得事务结束后依然满足a+b=10，否则事务失败。  
（3）I (Isolation) 独立性  
所谓的独立性是指并发的事务之间不会互相影响，如果一个事务要访问的数据正在被另外一个事务修改，只要另外一个事务未提交，它所访问的数据就不受未提交事务的影响。  
比如现有有个交易是从A账户转100元至B账户，在这个交易还未完成的情况下，如果此时B查询自己的账户，是看不到新增加的100元的。  
（4）D (Durability) 持久性  
持久性是指一旦事务提交后，它所做的修改将会永久的保存在数据库上，即使出现宕机也不会丢失。  
2、什么是NoSQL?  
NoSQL，指的是非关系型的数据库。NoSQL有时也称作Not Only SQL的缩写，是对不同于传统的关系型数据库的数据库管理系统的统称。  
NoSQL用于超大规模数据的存储。（例如谷歌或Facebook每天为他们的用户收集万亿比特的数据）。这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展。  
3、为什么使用NoSQL ?  
今天我们可以通过第三方平台（如：Google,Facebook等）可以很容易的访问和抓取数据。用户的个人信息，社交网络，地理位置，用户生成的数据和用户操作日志已经成倍的增加。我们如果要对这些用户数据进行挖掘，那SQL数据库已经不适合这些应用了, NoSQL数据库的发展也却能很好的处理这些大的数据。  
4、RDBMS vs NoSQL  
（1）RDBMS  
高度组织化结构化数据  
结构化查询语言（SQL） (SQL)  
数据和关系都存储在单独的表中。  
数据操纵语言，数据定义语言  
严格的一致性  
基础事务  
（2）NoSQL  
代表着不仅仅是SQL  
没有声明性查询语言  
没有预定义的模式  
\-键 - 值对存储，列存储，文档存储，图形数据库  
最终一致性，而非ACID属性  
非结构化和不可预知的数据  
CAP定理  
高性能，高可用性和可伸缩性

# 二、MongoDB简介 #

MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写。旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。  
MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。  
1、什么是MongoDB ?  
MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。  
在高负载的情况下，添加更多的节点，可以保证服务器性能。  
MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。  
MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。

2、主要特点  
MongoDB的提供了一个面向文档存储，操作起来比较简单和容易。  
你可以在MongoDB记录中设置任何属性的索引 (如：FirstName=“Sameer”,Address=“8 Gandhi Road”)来实现更快的排序。  
你可以通过本地或者网络创建数据镜像，这使得MongoDB有更强的扩展性。  
如果负载的增加（需要更多的存储空间和更强的处理能力） ，它可以分布在计算机网络中的其他节点上这就是所谓的分片。  
Mongo支持丰富的查询表达式。查询指令使用JSON形式的标记，可轻易查询文档中内嵌的对象及数组。  
MongoDb 使用update()命令可以实现替换完成的文档（数据）或者一些指定的数据字段 。  
Mongodb中的Map/reduce主要是用来对数据进行批量处理和聚合操作。  
Map和Reduce。Map函数调用emit(key,value)遍历集合中所有的记录，将key与value传给Reduce函数进行处理。  
Map函数和Reduce函数是使用Javascript编写的，并可以通过db.runCommand或mapreduce命令来执行MapReduce操作。  
GridFS是MongoDB中的一个内置功能，可以用于存放大量小文件。  
MongoDB允许在服务端执行脚本，可以用Javascript编写某个函数，直接在服务端执行，也可以把函数的定义存储在服务端，下次直接调用即可。  
MongoDB支持各种编程语言:RUBY，PYTHON，JAVA，C++，PHP，C\#等多种语言。  
MongoDB安装简单。

# Mongo安装与启动： #

下载完成之后将bin路径加到环境变量中。  
在mongodb目录中新建data文件夹  
在管理员模式下打开cmd，启动mongodb：

注意路径中不能出现中文，可能会造成找不到文件夹。  
新开一个cmd， 进入到mongo中：

三、MongoDB基础操作  
1、MongoDB概念解析  
在mongodb中基本的概念是文档、集合、数据库，下面我们挨个介绍。  
SQL术语/概念 MongoDB术语/概念 解释/说明  
database database 数据库  
table collection 数据库表/集合  
row document 数据记录行/文档  
column field 数据字段/域  
index index 索引  
table joins 表连接,MongoDB不支持  
primary key primary key 主键,MongoDB自动将\_id字段设置为主键  
通过下图实例，我们也可以更直观的的了解Mongo中的一些概念：  
（1）数据库初步  
一个mongodb中可以建立多个数据库。  
MongoDB的默认数据库为"db"，该数据库存储在data目录中。  
MongoDB的单个实例可以容纳多个独立的数据库，每一个都有自己的集合和权限，不同的数据库也放置在不同的文件中。  
"show dbs"命令可以显示所有数据的列表。  
$ mongo  
MongoDB shell version: 3.0.6  
connecting to: test

> show dbs  
> local 0.078GB  
> test 0.078GB

执行"db"命令可以显示当前数据库对象或集合。  
$ mongo  
MongoDB shell version: 3.0.6  
connecting to: test

> db  
> test

运行"use"命令，可以连接到一个指定的数据库。

> use local  
> switched to db local  
> db  
> local

以上实例命令中，“local” 是你要链接的数据库。  
在下一个章节我们将详细讲解MongoDB中命令的使用。  
数据库也通过名字来标识。数据库名可以是满足以下条件的任意UTF-8字符串。  
不能是空字符串（"")。  
不得含有’ '（空格)、.、KaTeX parse error: Undefined control sequence: \\和 at position 4: 、/、\\̲和̲\\0 (空字符)。 应全部小…有特别的意义，只有在特定环境下才能使用。  
以下划线"\_“开头的键是保留的(不是严格要求的)。  
（3）集合  
集合就是 MongoDB 文档组，类似于 RDBMS （关系数据库管理系统：Relational Database Management System)中的表格。  
集合存在于数据库中，集合没有固定的结构，这意味着你在对集合可以插入不同格式和类型的数据，但通常情况下我们插入集合的数据都会有一定的关联性。  
比如，我们可以将以下不同数据结构的文档插入到集合中：  
\{“site”:“www.baidu.com”\}  
\{“site”:“www.google.com”,“name”:“Google”\}  
\{“site”:“www.runoob.com”,“name”:“菜鸟教程”,“num”:5\}  
当第一个文档插入时，集合就会被创建。  
（4）合法的集合名  
集合名不能是空字符串”"。  
集合名不能含有\\0字符（空字符)，这个字符表示集合名的结尾。  
集合名不能以"system."开头，这是为系统集合保留的前缀。  
用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含，这是因为某些系统生成的集合中包含该字符。除非你要访问这种系统创建的集合，否则千万不要在名字里出现$。　  
如下实例：  
db.col.findOne()  
2、MongoDB 创建数据库（use database\_name）  
（1）语法  
MongoDB 创建数据库的语法格式如下：  
use DATABASE\_NAME  
如果数据库不存在，则创建数据库，否则切换到指定数据库。  
（2）实例  
以下实例我们创建了数据库 runoob:

> use runoob  
> switched to db runoob  
> db  
> runoob

如果你想查看所有数据库，可以使用show dbs命令：

> show dbs  
> local 0.078GB  
> test 0.078GB

可以看到，我们刚创建的数据库 runoob 并不在数据库的列表中， 要显示它，我们需要向 runoob 数据库插入一些数据。

> db.runoob.insert(\{“name”:“菜鸟教程”\})  
> WriteResult(\{ “nInserted” : 1 \})  
> show dbs  
> local 0.078GB  
> runoob 0.078GB  
> test 0.078GB

MongoDB 中默认的数据库为 test，如果你没有创建新的数据库，集合将存放在 test 数据库中。  
3、MongoDB 删除数据库（db.dropDatabase()）  
语法  
MongoDB 删除数据库的语法格式如下：  
db.dropDatabase()  
删除当前数据库，默认为 test，你可以使用 db 命令查看当前数据库名。  
实例  
以下实例我们删除了数据库 runoob。  
首先，查看所有数据库：

> show dbs  
> local 0.078GB  
> runoob 0.078GB  
> test 0.078GB  
> 接下来我们切换到数据库 runoob：  
> use runoob  
> switched to db runoob

执行删除命令：

> db.dropDatabase()  
> \{ “dropped” : “runoob”, “ok” : 1 \}  
> 最后，我们再通过 show dbs 命令数据库是否删除成功：  
> show dbs  
> local 0.078GB  
> test 0.078GB

4、删除集合（db.collection.drop()）  
集合删除语法格式如下：  
db.collection.drop()  
以下实例删除了 runoob 数据库中的集合 site：

> use runoob  
> switched to db runoob  
> show tables  
> site  
> db.site.drop()  
> true  
> show tables

5、MongoDB插入文档（db.col.insert/save(doc)）  
本章节中我们将向大家介绍如何将数据插入到MongoDB的集合中。  
文档的数据结构和JSON基本一样。  
所有存储在集合中的数据都是BSON格式。  
BSON是一种类json的一种二进制形式的存储格式,简称Binary JSON。  
插入文档  
MongoDB 使用 insert() 或 save() 方法向集合中插入文档，语法如下：  
db.COLLECTION\_NAME.insert(document)  
实例  
以下文档可以存储在 MongoDB 的 runoob 数据库 的 col 集合中：

> db.col.insert(\{title: ‘MongoDB 教程’,  
> description: ‘MongoDB 是一个 Nosql 数据库’,  
> by: ‘菜鸟教程’,  
> url: ‘http://www.runoob.com’,  
> tags: \[‘mongodb’, ‘database’, ‘NoSQL’\],  
> likes: 100  
> \})  
> 以上实例中 col 是我们的集合名，如果该集合不在该数据库中， MongoDB 会自动创建该集合并插入文档。  
> 查看已插入文档：  
> db.col.find()  
> \{ “\_id” : ObjectId(“56064886ade2f21f36b03134”), “title” : “MongoDB 教程”, “description” : “MongoDB 是一个 Nosql 数据库”,  
> “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “mongodb”, “database”, “NoSQL” \], “likes” : 100 \}

我们也可以将数据定义为一个变量，如下所示：

> document=(\{title: ‘MongoDB 教程’,  
> description: ‘MongoDB 是一个 Nosql 数据库’,  
> by: ‘菜鸟教程’,  
> url: ‘http://www.runoob.com’,  
> tags: \[‘mongodb’, ‘database’, ‘NoSQL’\],  
> likes: 100  
> \});  
> 执行后显示结果如下：  
> \{  
> “title” : “MongoDB 教程”,  
> “description” : “MongoDB 是一个 Nosql 数据库”,  
> “by” : “菜鸟教程”,  
> “url” : “http://www.runoob.com”,  
> “tags” : \[  
> “mongodb”,  
> “database”,  
> “NoSQL”  
> \],  
> “likes” : 100  
> \}  
> 执行插入操作：  
> db.col.insert(document)  
> WriteResult(\{ “nInserted” : 1 \})

插入文档你也可以使用 db.col.save(document) 命令。如果不指定 \_id 字段 save() 方法类似于 insert() 方法。如果指定 \_id 字段，则会更新该 \_id 的数据。

6、MongoDB 更新文档（db.col.update/save(doc)）  
MongoDB 使用update()和save()方法来更新集合中的文档。接下来让我们详细来看下两个函数的应用及其区别。  
（1）update() 方法  
update() 方法用于更新已存在的文档。语法格式如下：  
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 :可选，抛出异常的级别。  
实例  
我们在集合 col 中插入如下数据：

> db.col.insert(\{  
> title: ‘MongoDB 教程’,  
> description: ‘MongoDB 是一个 Nosql 数据库’,  
> by: ‘菜鸟教程’,  
> url: ‘http://www.runoob.com’,  
> tags: \[‘mongodb’, ‘database’, ‘NoSQL’\],  
> likes: 100  
> \})  
> 接着我们通过 update() 方法来更新标题(title):  
> db.col.update(\{‘title’:‘MongoDB 教程’\},\{$set:\{‘title’:‘MongoDB’\}\})  
> WriteResult(\{ “nMatched” : 1, “nUpserted” : 0, “nModified” : 1 \}) \# 输出信息  
> db.col.find().pretty()  
> \{  
> “\_id” : ObjectId(“56064f89ade2f21f36b03136”),  
> “title” : “MongoDB”,  
> “description” : “MongoDB 是一个 Nosql 数据库”,  
> “by” : “菜鸟教程”,  
> “url” : “http://www.runoob.com”,  
> “tags” : \[  
> “mongodb”,  
> “database”,  
> “NoSQL”  
> \],  
> “likes” : 100  
> \}

可以看到标题(title)由原来的 “MongoDB 教程” 更新为了 “MongoDB”。  
以上语句只会修改第一条发现的文档，如果你要修改多条相同的文档，则需要设置 multi 参数为 true。

> db.col.update(\{‘title’:‘MongoDB 教程’\},\{$set:\{‘title’:‘MongoDB’\}\},\{multi:true\})  
> （2）save() 方法  
> save() 方法通过传入的文档来替换已有文档。语法格式如下：  
> db.collection.save(  
> ,  
> \{  
> writeConcern:  
> \}  
> )  
> 参数说明：  
> document : 文档数据。  
> writeConcern :可选，抛出异常的级别。  
> 实例  
> 以下实例中我们替换了 \_id 为 56064f89ade2f21f36b03136 的文档数据：  
> db.col.save(\{  
> “\_id” : ObjectId(“56064f89ade2f21f36b03136”),  
> “title” : “MongoDB”,  
> “description” : “MongoDB 是一个 Nosql 数据库”,  
> “by” : “Runoob”,  
> “url” : “http://www.runoob.com”,  
> “tags” : \[  
> “mongodb”,  
> “NoSQL”  
> \],  
> “likes” : 110  
> \})  
> 替换成功后，我们可以通过 find() 命令来查看替换后的数据  
> db.col.find().pretty()  
> \{  
> “\_id” : ObjectId(“56064f89ade2f21f36b03136”),  
> “title” : “MongoDB”,  
> “description” : “MongoDB 是一个 Nosql 数据库”,  
> “by” : “Runoob”,  
> “url” : “http://www.runoob.com”,  
> “tags” : \[  
> “mongodb”,  
> “NoSQL”  
> \],  
> “likes” : 110  
> \}

更多实例

只更新找到符合条件的第一条  
db.col.update( \{ “count” : \{ $gt : 1 \} \} , \{ $set : \{ “sex” : “女”\} \} );

全部更新： 找到符合条件的全部更新,如果没有符合条件的不会进行添加数据 如果符合条件的数据中没有对应字段,就会添加字段和数据  
db.col.update( \{ “count” : \{ $gt : 20 \} \} , \{ $set : \{ “sex” : “OK”,“love”:“iloveyou”\} \},false,true );

如果能找到第一个符合条件的数据 就进行修改 如果没有找到符合条件的就是进行添加数据  
db.col.update( \{ “count” : \{ $lt : 2 \} \} , \{ $set : \{ “test5” : “OK”\} \},true,false );

找符合条件的所有数据进行修改.,如果没有符合条件的数据 就进行添加  
db.col.update( \{ “count” : \{ $lt : 5 \} \} , \{ $set : \{ “test6” : “OK”\} \},true,true );

全部更新：  
db.col.update( \{ “count” : \{ $gt : 15 \} \} , \{ $inc : \{ “count” : 1\} \},false,true );  
只更新第一条记录：  
7、MongoDB 删除文档（db.col.remove()）  
在前面的几个章节中我们已经学习了MongoDB中如何为集合添加数据和更新数据。在本章节中我们将继续学习MongoDB集合的删除。  
MongoDB remove()函数是用来移除集合中的数据。  
MongoDB数据更新可以使用update()函数。在执行remove()函数前先执行find()命令来判断执行的条件是否正确，这是一个比较好的习惯。  
语法  
remove() 方法的基本语法格式如下所示：  
db.collection.remove(  
,  
  
)  
如果你的 MongoDB 是 2.6 版本以后的，语法格式如下：  
db.collection.remove(  
,  
\{  
justOne: ,  
writeConcern:  
\}  
)  
参数说明：  
query :（可选）删除的文档的条件。  
justOne : （可选）如果设为 true 或 1，则只删除一个文档。  
writeConcern :（可选）抛出异常的级别。  
实例  
以下文档我们执行两次插入操作：

> db.col.insert(\{title: ‘MongoDB 教程’,  
> description: ‘MongoDB 是一个 Nosql 数据库’,  
> by: ‘菜鸟教程’,  
> url: ‘http://www.runoob.com’,  
> tags: \[‘mongodb’, ‘database’, ‘NoSQL’\],  
> likes: 100  
> \})  
> 使用 find() 函数查询数据：  
> db.col.find()  
> \{ “\_id” : ObjectId(“56066169ade2f21f36b03137”), “title” : “MongoDB 教程”, “description” : “MongoDB 是一个 Nosql 数据库”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “mongodb”, “database”, “NoSQL” \], “likes” : 100 \}  
> \{ “\_id” : ObjectId(“5606616dade2f21f36b03138”), “title” : “MongoDB 教程”, “description” : “MongoDB 是一个 Nosql 数据库”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “mongodb”, “database”, “NoSQL” \], “likes” : 100 \}  
> 接下来我们移除 title 为 ‘MongoDB 教程’ 的文档：  
> db.col.remove(\{‘title’:‘MongoDB 教程’\})  
> WriteResult(\{ “nRemoved” : 2 \}) \# 删除了两条数据  
> db.col.find()  
> …… \# 没有数据  
> 如果你只想删除第一条找到的记录可以设置 justOne 为 1，如下所示：  
> db.COLLECTION\_NAME.remove(DELETION\_CRITERIA,1)  
> 如果你想删除所有数据，可以使用以下方式（类似常规 SQL 的 truncate 命令）：  
> db.col.remove(\{\})  
> db.col.find()

8、MongoDB 查询文档（cb.col.find()）  
MongoDB 查询文档使用 find() 方法。  
find() 方法以非结构化的方式来显示所有文档。  
语法  
MongoDB 查询数据的语法格式如下：  
db.collection.find(query, projection)  
query ：可选，使用查询操作符指定查询条件  
projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。  
如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，语法格式如下：

> db.col.find().pretty()  
> pretty() 方法以格式化的方式来显示所有文档。  
> 实例  
> 以下实例我们查询了集合 col 中的数据：  
> db.col.find().pretty()  
> \{  
> “\_id” : ObjectId(“56063f17ade2f21f36b03133”),  
> “title” : “MongoDB 教程”,  
> “description” : “MongoDB 是一个 Nosql 数据库”,  
> “by” : “菜鸟教程”,  
> “url” : “http://www.runoob.com”,  
> “tags” : \[  
> “mongodb”,  
> “database”,  
> “NoSQL”  
> \],  
> “likes” : 100  
> \}  
> 除了 find() 方法之外，还有一个 findOne() 方法，它只返回一个文档。  
> 9、MongoDB 与 RDBMS Where 语句比较  
> 如果你熟悉常规的 SQL 数据，通过下表可以更好的理解 MongoDB 的条件语句查询：  
> 操作 格式 范例 RDBMS中的类似语句  
> 等于 \{:\} db.col.find(\{“by”:“菜鸟教程”\}).pretty() where by = ‘菜鸟教程’  
> 小于 \{:\{ KaTeX parse error: Expected 'EOF', got '\}' at position 11: lt:<value>\}̲\} db.col.find(\{…lt:50\}\}).pretty() where likes < 50  
> 小于或等于 \{:\{ KaTeX parse error: Expected 'EOF', got '\}' at position 12: lte:<value>\}̲\} db.col.find(\{…lte:50\}\}).pretty() where likes <= 50  
> 大于 \{:\{ KaTeX parse error: Expected 'EOF', got '\}' at position 11: gt:<value>\}̲\} db.col.find(\{…gt:50\}\}).pretty() where likes > 50  
> 大于或等于 \{:\{ KaTeX parse error: Expected 'EOF', got '\}' at position 12: gte:<value>\}̲\} db.col.find(\{…gte:50\}\}).pretty() where likes >= 50  
> 不等于 \{:\{ KaTeX parse error: Expected 'EOF', got '\}' at position 11: ne:<value>\}̲\} db.col.find(\{…ne:50\}\}).pretty() where likes != 50

10、MongoDB AND 条件  
MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，及常规 SQL 的 AND 条件。  
语法格式如下：

> db.col.find(\{key1:value1, key2:value2\}).pretty()  
> 实例  
> 以下实例通过by和title键来查询菜鸟教程中MongoDB 教程的数据  
> db.col.find(\{“by”:“菜鸟教程”, “title”:“MongoDB 教程”\}).pretty()  
> \{  
> “\_id” : ObjectId(“56063f17ade2f21f36b03133”),  
> “title” : “MongoDB 教程”,  
> “description” : “MongoDB 是一个 Nosql 数据库”,  
> “by” : “菜鸟教程”,  
> “url” : “http://www.runoob.com”,  
> “tags” : \[  
> “mongodb”,  
> “database”,  
> “NoSQL”  
> \],  
> “likes” : 100  
> \}  
> 以上实例中类似于 WHERE 语句：WHERE by=‘菜鸟教程’ AND title=‘MongoDB 教程’  
> 11、MongoDB OR 条件  
> MongoDB OR 条件语句使用了关键字$or,语法格式如下：  
> db.col.find(  
> \{  
> KaTeX parse error: Expected 'EOF', got '\}' at position 57: …e2\} \] \}̲ ).pretty() 实例 …or:\[\{“by”:“菜鸟教程”\},\{“title”: “MongoDB 教程”\}\]\}).pretty()  
> \{  
> “\_id” : ObjectId(“56063f17ade2f21f36b03133”),  
> “title” : “MongoDB 教程”,  
> “description” : “MongoDB 是一个 Nosql 数据库”,  
> “by” : “菜鸟教程”,  
> “url” : “http://www.runoob.com”,  
> “tags” : \[  
> “mongodb”,  
> “database”,  
> “NoSQL”  
> \],  
> “likes” : 100  
> \}

12、AND 和 OR 联合使用  
以下实例演示了 AND 和 OR 联合使用，类似常规 SQL 语句为：‘where likes>50 AND (by = ‘菜鸟教程’ OR title = ‘MongoDB 教程’)’

> db.col.find(\{“likes”: \{$gt:50\}, $or: \[\{“by”: “菜鸟教程”\},\{“title”: “MongoDB 教程”\}\]\}).pretty()  
> \{  
> “\_id” : ObjectId(“56063f17ade2f21f36b03133”),  
> “title” : “MongoDB 教程”,  
> “description” : “MongoDB 是一个 Nosql 数据库”,  
> “by” : “菜鸟教程”,  
> “url” : “http://www.runoob.com”,  
> “tags” : \[  
> “mongodb”,  
> “database”,  
> “NoSQL”  
> \],  
> “likes” : 100  
> \}  
> 实例练习

查询user集合中 uname=“张三” and age=21 的所有文档

> db.user.find(\{“uname”:“zhangsan”,“age”:21\}).pretty()

查询user集合中 uname=zhangsan 或者 uname="张三"的数据

> db.user.find(\{$or:\[\{“uname”:“zhangsan”\},\{“uname”: “张三”\}\]\}).pretty()

查询user集合中 age=21 uname=张三或uname=zhangsan

> db.user.find(\{“age”:21,$or:\[\{“uname”:“zhangsan”\},\{“uname”: “张三”\}\]\}).pretty()

限制返回的数据字段

> db.user.find(\{“uname”:“zhangsan”,“age”:21\},\{"\_id":1,“uname”:1\}).pretty()  
> \{ “\_id” : ObjectId(“59f02a93efa271499313b6a4”), “uname” : “zhangsan” \}  
> \{ “\_id” : ObjectId(“59f02abbefa271499313b6a5”), “uname” : “zhangsan” \}  
> 13、MongoDB条件操作符  
> 描述  
> 条件操作符用于比较两个表达式并从mongoDB集合中获取数据。  
> 在本章节中，我们将讨论如何在MongoDB中使用条件操作符。  
> MongoDB中条件操作符有：  
> $gt ----大于 ---- greater than >  
> $gte ----大于等于----- gt equal >=  
> $lt —小于----- less than <  
> $lte —小于等于------ lt equal <=  
> $ne —不等于------ not equal !=  
>  e q − − − − 等 于 − − − − e q u a l = 14 、 eq ----等于---- equal = 14、 eq−−−−等于−−−−equal=14、type操作符  
> 在本章节中，我们将继续讨论MongoDB中条件操作符 $type。  
> $type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果  
> 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  
> 64-bit integer 18  
> Min key 255 Query with-1.  
> Max key 127  
> 我们使用的数据库名称为"runoob" 我们的集合名称为"col"，以下为我们插入的数据。  
> db.col.insert(\{  
> title: ‘PHP 教程’,  
> description: ‘PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。’,  
> by: ‘菜鸟教程’,  
> url: ‘http://www.runoob.com’,  
> tags: \[‘php’\],  
> likes: 200  
> \})  
> db.col.insert(\{title: ‘Java 教程’,  
> description: ‘Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。’,  
> by: ‘菜鸟教程’,  
> url: ‘http://www.runoob.com’,  
> tags: \[‘java’\],  
> likes: 150  
> \})  
> db.col.insert(\{title: ‘MongoDB 教程’,  
> description: ‘MongoDB 是一个 Nosql 数据库’,  
> by: ‘菜鸟教程’,  
> url: ‘http://www.runoob.com’,  
> tags: \[‘mongodb’\],  
> likes: 100  
> \})  
> 使用find()命令查看数据：  
> db.col.find()  
> \{ “\_id” : ObjectId(“56066542ade2f21f36b0313a”), “title” : “PHP 教程”, “description” : “PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “php” \], “likes” : 200 \}  
> \{ “\_id” : ObjectId(“56066549ade2f21f36b0313b”), “title” : “Java 教程”, “description” : “Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “java” \], “likes” : 150 \}  
> \{ “\_id” : ObjectId(“5606654fade2f21f36b0313c”), “title” : “MongoDB 教程”, “description” : “MongoDB 是一个 Nosql 数据库”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “mongodb” \], “likes” : 100 \}  
> KaTeX parse error: Expected '\}', got 'EOF' at end of input: …nd(\{"title" : \{ type : 2\}\})  
> \{ “\_id” : ObjectId(“56066542ade2f21f36b0313a”), “title” : “PHP 教程”, “description” : “PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “php” \], “likes” : 200 \}  
> \{ “\_id” : ObjectId(“56066549ade2f21f36b0313b”), “title” : “Java 教程”, “description” : “Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “java” \], “likes” : 150 \}  
> \{ “\_id” : ObjectId(“5606654fade2f21f36b0313c”), “title” : “MongoDB 教程”, “description” : “MongoDB 是一个 Nosql 数据库”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “mongodb” \], “likes” : 100 \}  
> 15、MongoDB Limit() 方法  
> 如果你需要在MongoDB中读取指定数量的数据记录，可以使用MongoDB的Limit方法，limit()方法接受一个数字参数，该参数指定从MongoDB中读取的记录条数。  
> 语法  
> limit()方法基本语法如下所示：  
> db.COLLECTION\_NAME.find().limit(NUMBER)  
> 实例  
> 集合 col 中的数据如下：  
> \{ “\_id” : ObjectId(“56066542ade2f21f36b0313a”), “title” : “PHP 教程”, “description” : “PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “php” \], “likes” : 200 \}  
> \{ “\_id” : ObjectId(“56066549ade2f21f36b0313b”), “title” : “Java 教程”, “description” : “Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “java” \], “likes” : 150 \}  
> \{ “\_id” : ObjectId(“5606654fade2f21f36b0313c”), “title” : “MongoDB 教程”, “description” : “MongoDB 是一个 Nosql 数据库”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “mongodb” \], “likes” : 100 \}  
> 以上实例为显示查询文档中的两条记录：  
> db.col.find(\{\},\{“title”:1,\_id:0\}).limit(2)  
> \{ “title” : “PHP 教程” \}  
> \{ “title” : “Java 教程” \}

注：如果你们没有指定limit()方法中的参数则显示集合中的所有数据。  
16、MongoDB Skip() 方法  
我们除了可以使用limit()方法来读取指定数量的数据外，还可以使用skip()方法来跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数。  
语法  
skip() 方法脚本语法格式如下：

> db.COLLECTION\_NAME.find().limit(NUMBER).skip(NUMBER)  
> 实例  
> 以上实例只会显示第二条文档数据  
> db.col.find(\{\},\{“title”:1,\_id:0\}).limit(1).skip(1)  
> \{ “title” : “Java 教程” \}

注:skip()方法默认参数为 0 。

Jump=(page-1)  
Db.col.find().pretty().limit(10).skip(jump)

Sql 分页  
Limit jump

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

> db.COLLECTION\_NAME.find().sort(\{KEY:1\})  
> 实例  
> col 集合中的数据如下：  
> \{ “\_id” : ObjectId(“56066542ade2f21f36b0313a”), “title” : “PHP 教程”, “description” : “PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “php” \], “likes” : 200 \}  
> \{ “\_id” : ObjectId(“56066549ade2f21f36b0313b”), “title” : “Java 教程”, “description” : “Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “java” \], “likes” : 150 \}  
> \{ “\_id” : ObjectId(“5606654fade2f21f36b0313c”), “title” : “MongoDB 教程”, “description” : “MongoDB 是一个 Nosql 数据库”, “by” : “菜鸟教程”, “url” : “http://www.runoob.com”, “tags” : \[ “mongodb” \], “likes” : 100 \}  
> 以下实例演示了 col 集合中的数据按字段 likes 的降序排列：  
> db.col.find(\{\},\{“title”:1,\_id:0\}).sort(\{“likes”:-1\})  
> \{ “title” : “PHP 教程” \}  
> \{ “title” : “Java 教程” \}  
> \{ “title” : “MongoDB 教程” \}

18、MongoDB 排序 count()方法  
在MongoDB中使用使用count()方法对数据进行统计  
类似sql中 select count(\*) from mycol

> db.mycol.count()  
> 3  
> 19、MongoDB 聚合（db.col.aggregate()）  
> MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(\*)。  
> aggregate() 方法  
> MongoDB中聚合的方法使用aggregate()。  
> 语法  
> aggregate() 方法的基本语法格式如下所示：  
> db.COLLECTION\_NAME.aggregate(AGGREGATE\_OPERATION)  
> 实例  
> 集合中的数据如下：  
> \{  
> \_id: ObjectId(7df78ad8902c)  
> title: ‘MongoDB Overview’,  
> description: ‘MongoDB is no sql database’,  
> by\_user: ‘runoob.com’,  
> url: ‘http://www.runoob.com’,  
> tags: \[‘mongodb’, ‘database’, ‘NoSQL’\],  
> likes: 100  
> \},  
> \{  
> \_id: ObjectId(7df78ad8902d)  
> title: ‘NoSQL Overview’,  
> description: ‘No sql database is very fast’,  
> by\_user: ‘runoob.com’,  
> url: ‘http://www.runoob.com’,  
> 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(\[\{ KaTeX parse error: Expected '\}', got 'EOF' at end of input: …roup : \{\_id : "by\_user", num\_tutorial : \{$sum : 1\}\}\}\])  
> \{  
> “result” : \[  
> \{  
> “\_id” : “runoob.com”,  
> “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字段相同值的总和。  
下表展示了一些聚合的表达式:  
表达式 描述 实例  
KaTeX parse error: Expected '\}', got 'EOF' at end of input: …ol.aggregate(\[\{ group : \{\_id : "KaTeX parse error: Expected '\}', got 'EOF' at end of input: …um\_tutorial : \{ sum : “$likes”\}\}\}\])  
KaTeX parse error: Expected '\}', got 'EOF' at end of input: …ol.aggregate(\[\{ group : \{\_id : "KaTeX parse error: Expected '\}', got 'EOF' at end of input: …um\_tutorial : \{ avg : “$likes”\}\}\}\])  
KaTeX parse error: Expected '\}', got 'EOF' at end of input: …ol.aggregate(\[\{ group : \{\_id : "KaTeX parse error: Expected '\}', got 'EOF' at end of input: …um\_tutorial : \{ min : “$likes”\}\}\}\])  
KaTeX parse error: Expected '\}', got 'EOF' at end of input: …ol.aggregate(\[\{ group : \{\_id : "KaTeX parse error: Expected '\}', got 'EOF' at end of input: …um\_tutorial : \{ max : “$likes”\}\}\}\])  
20、MongoDB 索引（db.col.ensureIndex()）  
索引通常能够极大的提高查询的效率，如果没有索引，MongoDB在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。  
这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。  
索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构  
ensureIndex() 方法  
MongoDB使用 ensureIndex() 方法来创建索引。  
语法  
ensureIndex()方法基本语法格式如下所示：

> db.COLLECTION\_NAME.ensureIndex(\{KEY:1\})  
> 语法中 Key 值为你要创建的索引字段，1为指定按升序创建索引，如果你想按降序来创建索引指定为-1即可。  
> 实例  
> 添加普通索引  
> db.col.ensureIndex(\{“title”:1\})  
> 查询索引  
> db.col.getIndexes()  
> 删除索引  
> db.col.dropIndex(\{title:1\})  
> 添加唯一索引 注意 字段保持唯一 否则报错,删除后可以添加  
> db.lis.ensureIndex(\{name:1\},\{unique:true\})  
> 查询分析  
> db.lis.find(\{“name”:‘a’\}).explain()  
> ensureIndex() 方法中你也可以设置使用多个字段创建索引（关系型数据库中称作复合索引）。  
> db.col.ensureIndex(\{“title”:1,“description”:-1\})

ensureIndex() 接收可选参数，可选参数列表如下：  
Parameter Type Description  
background Boolean 建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引，即增加  
“background” 可选参数。 “background” 默认值为false。  
unique Boolean 建立的索引是否唯一。指定为true创建唯一索引。默认值为false.  
name string 索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成一个索引名称。  
实例  
在后台创建索引：  
db.values.ensureIndex(\{open: 1, close: 1\}, \{background: true\})  
通过在创建索引时加background:true 的选项，让创建工作在后台执行

# 四、MongoDB 备份(mongodump)与恢复(mongorestore) #

1、MongoDB数据备份  
在Mongodb中我们使用mongodump命令来备份MongoDB数据。该命令可以导出所有数据到指定目录中。  
mongodump命令可以通过参数指定导出的数据量级转存的服务器。  
语法  
mongodump命令脚本语法如下：

> mongodump -h dbhost -d dbname -o dbdirectory  
> \-h：B所在服务器地址，例如：127.0.0.1，当然也可以指定端口号：127.0.0.1:27017  
> \-d：  
> 需要备份的数据库实例，例如：test  
> \-o：  
> 备份的数据存放位置，例如：c:\\data\\dump，当然该目录需要提前建立，在备份完成后，系统自动在dump目录下建立一个test目录，这个目录里面存放该数据库实例的备份数据。  
> 实例  
> 先退出mongo客户端  
> mongodump -d py4 -o /home/yc/data/  
> 2、MongoDB数据恢复  
> mongodb使用 mongorestore 命令来恢复备份的数据。  
> 语法  
> mongorestore命令脚本语法如下：  
> mongorestore -h <:port> -d dbname  
> 退出mongo客户端执行  
> mongorestore -d py /home/yc/data/py4  
> –host <:port>, -h <:port>： MongoDB所在服务器地址，默认为： localhost:27017  
> –db , -d ：需要恢复的数据库实例，例如：test，当然这个名称也可以和备份时候的不一样，比如test2  
> –drop：恢复的时候，先删除当前数据，然后恢复备份的数据。就是说，恢复后，备份后添加修改的数据都会被删除，慎用哦！  
> ：mongorestore 最后的一个参数，设置备份数据所在位置，例如：c:\\data\\dump\\test。  
> 你不能同时指定  和 --dir 选项，–dir也可以设置备份目录。  
> –dir：指定备份的目录 你不能同时指定  和 --dir 选项。  
> 接下来我们执行以下命令:  
> mongorestore  
> 执行以上命令输出结果如下：  
> 五、Python 访问 MongoDB  
> 对于使用 Python 访问 MongoDB，需要先安装 `PyMongo` 软件包，该包实现了 Python 的 MongoDB 驱动。  
> 通过以下命令建立工作环境，安装软件包：  
> pip install pymongo  
> 安装后使用 pip3 list查看是否存在pymongo  
> 创建脚本或使用命令行模式  
> \#链接到 127.0.0.1 的mongo  
> client = pymongo.MongoClient(‘127.0.0.1’, 27017)  
> \#选择test库  
> db = client.test

# print(db) #

查询所有数据 db.test.find()  
for user in db.test.find():  
print(user)  
print(’  
’)  
通过 PyMongo 插入数据也非常简单，直接通过 `insert` 方法：

# 定义数据 #

data = \{‘name’: ‘Aiden’, ‘age’: 30\}

# 执行数据添加 #

db.test.insert(data)