MongoDB - 简介
官网：https://www.mongodb.com/javascript
MongoDB 是一个基于分布式文件存储的数据库，由 C++ 语言编写，旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。html
MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。前端
MongoDB - 安装及运行
- 下载
07/05/2017 Current Stable Release (3.4.6)java
https://www.mongodb.com/download-center#communitynode
- 建立数据目录
MongoDB 将数据目录存储在 db 目录下，需手动建立。angularjs
|
1
|
E:
\MongoDB\data\db
|
- 运行 MongoDB 服务器
为了从命令提示符下运行MongoDB服务器，你必须从MongoDB\bin目录中执行mongod.exe文件，不要关闭服务。ctrl + c关闭。web
|
1
|
mongod.exe --dbpath E:
\MongoDB\data\db
|
- MongoDB 后台管理
运行 mongo.exesql
MongoDB Shell是MongoDB自带的交互式Javascript shell,用来对MongoDB进行操做和管理的交互式环境。mongodb
- 将 MongoDB 服务器做为 Windows 服务运行
添加系统环境 path E:\MongoDB\Server\3.4\binshell
检测：cmd 中输入 mongod --help
新建文件：E:\MongoDB\logs\logs.log
将 MongoDB 服务器做为 Windows 服务随 Windows 启动而开启：
|
1
|
mongod.exe
--logpath "E:\MongoDB\logs\logs.log" --logappend --dbpath "E:\MongoDB\data" --directoryperdb --serviceName MongoDB --install
|
开启 MongoDB 服务：net start MongoDB
中止 MongoDB 服务：net stop MongoDB
删除 MongoDB 服务：sc delete MongoDB
接下来就能够在 cmd 中运行 E:\MongoDB\Server\3.4\bin 里面的 *.exe 程序了
- shell 控制台
mongo - 数据库的还原
mongorestore - 备份
mongodump
- mongodb 启动的参数
mongoDB - 主要特色
- MongoDB安装简单。
- MongoDB的提供了一个面向文档存储，没有表结构的概念，天天记录能够有彻底不一样的结构，操做起来比较简单和容易。
- 彻底的索引支持（单键索引、数组索引、全文索引、地理位置索引 等）
- 你能够经过本地或者网络建立数据镜像，这使得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 支持多种编程语言:C C++ C# .NET Erlang Haskell Java JavaScript Lisp node.JS Perl PHP Python Ruby Scala 等
mongoDB - 工具
监控
- Munin：网络和系统监控工具
- Gangila：网络和系统监控工具
- Cacti：用于查看CPU负载, 网络带宽利用率，它也提供了一个应用于监控 MongoDB 的插件。
GUI
- Robomongo（Robo 3T）
- Fang of Mongo – 网页式，由Django和jQuery所构成。
- Futon4Mongo – 一个CouchDB Futon web的mongodb山寨版。
- Mongo3 – Ruby写成。
- MongoHub – 适用于OSX的应用程序。
- Opricot – 一个基于浏览器的MongoDB控制台, 由PHP撰写而成。
- Database Master — Windows的mongodb管理工具
- RockMongo — 最好的PHP语言的MongoDB管理工具，轻量级, 支持多国语言.
mongoDB - 三大重要概念
1. database 数据库
多个集合逻辑上组织在一块儿，就是数据库。
数据库命名规范：
- 不能是空字符串（””)。
- 不得含有’ ‘（空格)、.、$、/、\和\0 (空字符)。
- 应所有小写。
- 最多64字节。
有一些数据库名是保留的，能够直接访问这些有特殊做用的数据库。
- admin： 从权限的角度来看，这是”root”数据库。要是将一个用户添加到这个数据库，这个用户自动继承全部数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，好比列出全部的数据库或者关闭服务器。
- local: 这个数据永远不会被复制，能够用来存储限于本地单台服务器的任意集合
- config: 当Mongo用于分片设置时，config数据库在内部使用，用于保存分片的相关信息。
2. collection 集合
多个文档组成一个集合，至关于关系数据库的表。
全部存储在集合中的数据都是 BSON 格式，BSON 是类 JSON 的一种二进制形式的存储格式，简称 Binary JSON。
集合名命名规范：
- 集合名不能是空字符串””。
- 集合名不能含有\0字符（空字符)，这个字符表示集合名的结尾。
- 集合名不能以”system.”开头，这是为系统集合保留的前缀。
- 用户建立的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含，这是由于某些系统生成的集合中包含该字符。除非你要访问这种系统建立的集合，不然千万不要在名字里出现$。
3. document 文档
MongoDB 将数据存储为一个文档，数据结构由键值对组成。
MongoDB 文档是一组键值对(即BSON，二进制的 JSON)，相似于 JSON 对象。字段值能够包含其余文档，数组及文档数组。
文档键命名规范：
- 键不能含有\0 (空字符)。这个字符用来表示键的结尾。
- .和$有特别的意义，只有在特定环境下才能使用。
- 如下划线”_”开头的键是保留的(不是严格要求的)。
须要注意的是：
- 文档中的键值对是有序的。
- 文档中的值不只能够是在双引号里面的字符串，还能够是其余几种数据类型（甚至能够是整个嵌入的文档)。
- MongoDB区分类型和大小写。
- MongoDB的文档不能有重复的键。
- 文档的键是字符串。除了少数例外状况，键可使用任意UTF-8字符。
MongoDB - 数据类型
ObjectId：主键，一种特殊并且很是重要的类型，每一个文档都会默认配置这个属性，属性名为_id，除非本身定义，方可覆盖
MongoDB - 常见操做
查看当前数据库
|
1
|
db
|
查看全部数据库
没有数据的数据库不予显示
MongoDB 中默认的数据库为 test，若是你没有建立新的数据库，集合将存放在 test 数据库中。
|
1
|
show dbs
|
链接到指定的数据库
若是数据库不存在，则建立数据库，不然切换到指定数据库。
|
1
|
use db_name
|
查看服务器状态
|
1
|
db.serverStatus()
|
查看数据库统计信息
|
1
|
db.stats()
|
删除数据库
|
1
|
db.dropDatabase()
|
查看数据库中全部集合
|
1
2
3
|
show tables
或
show collections
|
清空集合
删除里面的文档，但集合还在
|
1
|
db.col_name.remove({})
|
删除集合
|
1
|
db
.col_name.drop()
|
查看集合详细信息
MongoDB 的3.0后的版本分了三种模式 queryPlanner、executionStats、allPlansExecution
|
1
|
db.col_name.find({key:value}).explain("allPlansExecution")
|
MongoDB - 增删改查
插入
MongoDB 使用 insert() 或 save() 方法向集合中插入文档：
若是该集合不在该数据库中， MongoDB 会自动建立该集合并插入文档。
insert() 或 save() 方法均可以向collection里插入数据，二者区别：
- 若是不指定 _id 字段，save() 方法相似于 insert() 方法。若是指定 _id 字段，则会更新该 _id 的数据。
- 使用save函数，若是原来的对象不存在，那他们均可以向collection里插入数据，若是已经存在，save会调用update更新里面的记录，而insert则会忽略操做
- insert能够一次性插入一个列表，而不用遍历，效率高， save则须要遍历列表，一个个插入。
|
1
2
3
|
db
.col_name.insert(document)
db
.col_name.save(document)
|
插入一个文档到 col 集合中：
|
1
2
3
4
5
6
7
8
|
db.col_1.insert({
title: 'MongoDB 教程',
description:
'MongoDB 是一个 Nosql 数据库',
by:
'菜鸟教程',
url:
'http://www.runoob.com',
tags: [
'mongodb', 'database', 'NoSQL'],
likes:
100
})
|
也能够将文档数据定义为一个变量，以下所示：
|
1
2
3
4
5
6
7
8
9
10
|
document = ({
title:
'MongoDB 教程',
description:
'MongoDB 是一个 Nosql 数据库',
by:
'菜鸟教程',
url:
'http://www.runoob.com',
tags: [
'mongodb', 'database', 'NoSQL'],
likes:
100
});
db.col_2.insert(
document)
|
删除
remove() 函数是用来删除集合中的数据
在执行 remove() 函数前先执行 find() 命令来判断执行的条件是否正确，这是一个比较好的习惯。
|
1
2
3
4
5
6
7
8
9
10
11
|
db.col_name.remove(
<
query>,
{
justOne: <boolean>,
writeConcern: <document>
}
)
- query :（可选）删除的文档的条件。
- justOne : （可选）若是设为 true 或 1，则只删除一个文档。
- writeConcern :（可选）抛出异常的级别。
|
删除集合中全部文档
|
1
|
db.col.remove({})
|
移除 col_1 集合中 title 为 MongoDB save 的文档，只删除第一条找到的记录
|
1
|
db
.col_1.remove({'title':'MongoDB save'}, 1)
|
更新
MongoDB 使用 update() 和 save() 方法来更新集合中的文档
update() 方法用于更新已存在的文档
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
db.col_name.update(
<query>,
<
update>,
{
upsert: <boolean>,
multi: <
boolean>,
writeConcern: <document>
}
)
- query :
update 的查询条件，相似sql update查询内where后面的。
-
update : update的对象和一些更新的操做符（如$,$inc...）等，也能够理解为sql update查询内set后面的
-
upsert : 可选，这个参数的意思是，若是不存在 update 的记录，是否插入记录，true 为插入，默认是 false，不插入。
- multi : 可选，mongodb 默认是
false,只更新找到的第一条记录，若是这个参数为true,就把按条件查出来多条记录所有更新。
- writeConcern :可选，抛出异常的级别。
|
经过 update() 方法来更新 col_1 集合中的 title
$set 操做符为部分更新操做符，只更新 $set 以后的数据，而不是覆盖以前的数据
|
1
|
db.col_1.
update({ 'title': 'MongoDB 教程' }, { $set: { 'title': 'MongoDB' } })
|
以上语句只会修改第一条发现的文档，若是要修改多条相同的文档，则须要设置 multi 参数为 true。
|
1
|
db.col_1.
update({ 'title': 'MongoDB 教程' }, { $set: { 'title': 'MongoDB' } }, { multi: true })
|
save() 方法经过传入的文档来替换已有文档。语法格式以下：
|
1
2
3
4
5
6
|
db.col_name.save(
<
document>,
{
writeConcern: <document>
}
)
|
如下实例中咱们替换了 col_1 的文档数据：
|
1
2
3
4
5
6
7
8
9
10
|
document = ({
"_id": "1",
"title": "MongoDB save",
"description": "MongoDB 是一个 Nosql 数据库",
"by": "菜鸟",
"url": "http://www.runoob.com",
"tags": ["mongodb", "database", "NoSQL"],
});
db.col_1.save(
document)
|
查询
find() 方法，它返回集合中全部文档。
findOne() 方法，它只返回一个文档。
|
1
2
3
4
|
db.col_name.find(query, projection)
-
query ：可选，使用查询操做符指定查询条件
-
projection ：可选，使用投影操做符指定返回的键。查询时返回文档中全部键值， 只需省略该参数便可（默认省略）。
|
格式化输出：
|
1
|
db.col_name.find().pretty()
|
查看集合中文档的个数：
|
1
|
db.col_name.find().count()
|
跳过指定数量的数据：
|
1
|
db.col_name.find().skip()
|
读取指定记录的条数：
|
1
|
db.col_name.find().limit()
|
排序：
sort()方法能够经过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。
|
1
|
db.col_name.find().sort({key:1})
|
sort()方法能够经过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。
Where 语句
若是你想获取”col”集合中 “likes” 大于100，小于 200 的数据，你可使用如下命令：
|
1
2
3
4
|
db.col.find({likes : {
$lt :200, $gt : 100}})
// 相似于SQL语句：
Select * from col where likes>
100 AND likes<200;
|
| 条件操做符 | 中文 | 全英文 |
|---|---|---|
| $gt | 大于 | greater than |
| $gte | 大于等于 | greater than equal |
| $lt | 小于 | less than |
| $lte | 小于等于 | less than equal |
| $ne | 不等于 | not equal |
$type 操做符
用来检索集合中匹配的数据类型
若是想获取 “col” 集合中 title 为 String 的数据，你可使用如下命令：
|
1
|
db
.col.find({"title" : {$type : 2}})
|
AND 条件
find() 方法能够传入多个键(key)，每一个键(key)以逗号隔开，语法格式以下：
|
1
2
3
4
|
db.col_name.find(
{key1:value1, key2:value2}).pretty()
// 相似于 SQL and 语句：
SELECT * FROM col_name WHERE key1='value1' AND key2=value2
|
OR 条件
|
1
2
3
4
|
db.col_name.
find({ $or: [{ "by": "菜鸟教程" }, { "title": "MongoDB 教程" }] }).pretty()
// 相似于 SQL or 语句：
SELECT * FROM col_name WHERE key1=value1 OR key2=value2
|
AND 和 OR 联合使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
db.col_name.find({
"likes": {
$gt:
50
},
$or: [{
"by": "菜鸟教程"
}, {
"title": "MongoDB 教程"
}]
}).pretty()
// 相似常规 SQL 语句：
SELECT * FROM col_name
where likes>50 AND (by = '菜鸟教程' OR title = 'MongoDB 教程')
|
MongoDB - 索引
注意：从 mongoDB 3.0 开始，ensureIndex 被废弃，从此都仅仅是 createIndex 的一个别名。
索引一般可以极大的==提升查询的效率==，若是没有索引，MongoDB在读取数据时必须扫描集合中的每一个文件并选取那些符合查询条件的记录。
这种扫描全集合的查询效率是很是低的，特别在处理大量的数据时，查询能够要花费几十秒甚至几分钟，这对网站的性能是很是致命的。
索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构
索引经常使用命令
getIndexes 查看集合索引状况
|
1
|
db
.col_name.getIndexes()
|
hint 强制使用索引
|
1
|
db.col_name.find({age:{$lt:30}}).hint({name:1, age:1}).explain()
|
删除索引(不会删除 _id 索引)
|
1
2
3
|
db.col_name.dropIndexes()
db.col_name.dropIndex({firstname: 1})
|
createIndex() 方法
MongoDB使用 createIndex() 方法来建立索引
key 为你要建立的索引字段，1为按升序建立索引，-1为按降序建立索引。
也能够设置使用多个字段建立索引（关系型数据库中称做复合索引）
|
1
|
db.col_name.createIndex({key:1})
|
createIndex() 接收可选参数，可选参数列表以下：
_id 索引
对于每一个插入的数据，都会自动生成一条惟一的 _id 字段，_id 索引是绝大多数集合默认创建的索引
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
> db
.col_1.insert({x:10})
WriteResult({ "nInserted" : 1 })
> db
.col_1.find()
{
"_id" : ObjectId("59658e56aaf42d1c98dd95a2"), "x" : 10 }
> db
.col_1.getIndexes()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "runoob.col_1"
}
]
|
字段解释：
-
v 表示 version，在 Mongo3.2 以前的版本中，会存在 {v:0}（版本锁为0）的状况。在3.2以后的版本中，{v:0} 再也不容许使用，这部分能够不去关注，由于 v 由系统自动管理
-
key 表示做为索引的键。1 或 -1表示排序模式，1为升序，1为降序
-
name 表示索引的名字，默认生成名称的规则是做为
索引的字段_排序模式 -
ns 表示 namespace 命名空间，由
数据库名称.集合名称组成
单键索引
最普通的索引，不会自动建立
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
// 对 x 字段建立升序索引
> db
.col_1.createIndex({x:1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
> db
.col_1.find()
{
"_id" : ObjectId("59658e56aaf42d1c98dd95a2"), "x" : 10 }
> db
.col_1.getIndexes()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "runoob.col_1"
},
{
"v" : 2,
"key" : {
"x" : 1
},
"name" : "x_1",
"ns" : "runoob.col_1"
}
]
|
多键索引
单键索引的值为一个单一的值，多键索引的值有多个数据（如数组）
若是mongoDB中插入数组类型的多键数据，索引是自动创建的，无需刻意指定
|
1
2
3
4
5
6
7
8
9
10
|
> db
.col_1.insert({z:[1,2,3,4,5]})
WriteResult({ "nInserted" : 1 })
> db
.col_1.find()
{
"_id" : ObjectId("59658e56aaf42d1c98dd95a2"), "x" : 10 }
{
"_id" : ObjectId("5965923eaaf42d1c98dd95a3"), "y" : 20 }
{
"_id" : ObjectId("59659828aaf42d1c98dd95a4"), "z" : [ 1, 2, 3, 4, 5 ] }
> db
.col_1.find({z:3})
{
"_id" : ObjectId("59659828aaf42d1c98dd95a4"), "z" : [ 1, 2, 3, 4, 5 ] }
|
复合索引
同时对多个字段建立索引
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
> db
.col_2.insert({x:10,y:20,z:30})
WriteResult({ "nInserted" : 1 })
> db
.col_2.find()
{
"_id" : ObjectId("59659a57aaf42d1c98dd95a5"), "x" : 10, "y" : 20, "z" : 30 }
> db
.col_2.createIndex({x:1,y:1})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
> db
.col_2.getIndexes()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "runoob.col_2"
},
{
"v" : 2,
"key" : {
"x" : 1,
"y" : 1
},
"name" : "x_1_y_1",
"ns" : "runoob.col_2"
}
]
|
过时索引
又称 TTL（Time To Live，生存时间）索引，即在一段时间后会过时的索引（如登陆信息、日志等）
过时后的索引会连同文档一块儿删除
expireAfterSeconds：指定一个以秒为单位的数值，设定集合的生存时间。
注意：
- 存储在过时索引字段的值必须是指定的时间类型（必须是 ISODate 或 ISODate 数组，不能使用时间戳，不然不能被自动删除）
- 若是指定了 ISODate 数组，则按照最小的时间进行删除
- 过时索引不能是复合索引（不能指定两个过时时间）
- 删除时间存在些许偏差（1 分钟左右）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
> db
.col_3.insert({x:new Date()})
WriteResult({ "nInserted" : 1 })
> db
.col_3.find()
{
"_id" : ObjectId("59659f3baaf42d1c98dd95a7"), "x" : ISODate("2017-07-12T04:02:03.835Z") }
> db
.col_3.createIndex({x:1},{expireAfterSeconds:10})
{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}
> db
.col_3.getIndexes()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "runoob.col_3"
},
{
"v" : 2,
"key" : {
"x" : 1
},
"name" : "x_1",
"ns" : "runoob.col_3",
"expireAfterSeconds" : 10
}
]
> db
.col_3.find()
// 无返回
|
全文索引
场景：全网站关键词搜索
key-value 中，key 此时为 $**（也能够是具体某 key），value 此时为一个固定的字符串（如 text）
全文索引类似度，与 sort 函数一块儿使用效果更好
|
1
|
db.col_7.find({ $text: { $search:
"aa bb" } }, { score: { $meta: "textScore" } }).sort({ score: { $meta: "textScore" } })
|
注意：
- 每一个集合只能建立一个全文索引
- MongoDB 从 2.4 版本开始支持全文检索，从 3.2 版本开始支持中文
- （好像）只能对整个单词查询，不能对单词的截取部分查询
- 关键词之间的空格表示
或 - 关键词以前的 - 表示
非 - 关键词加引号表示
与（需用 \ 转义）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
> db.col_7.find()
{
"_id" : ObjectId("5965aa84aaf42d1c98dd95b0"), "title" : "aa bb cc", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
{
"_id" : ObjectId("5965aa8faaf42d1c98dd95b1"), "title" : "abc def", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
{
"_id" : ObjectId("5965aedfaaf42d1c98dd95b2"), "title" : "aa bb", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
> db.col_7.createIndex({
"title": "text"})
> db.col_7.find({$text:{$search:
"aa"}})
{
"_id" : ObjectId("5965aa84aaf42d1c98dd95b0"), "title" : "aa bb cc", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
{
"_id" : ObjectId("5965aedfaaf42d1c98dd95b2"), "title" : "aa bb", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
> db.col_7.find({$text:{$search:
"aa cc"}})
{
"_id" : ObjectId("5965aa84aaf42d1c98dd95b0"), "title" : "aa bb cc", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
{
"_id" : ObjectId("5965aedfaaf42d1c98dd95b2"), "title" : "aa bb", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
> db.col_7.find({$text:{$search:
"\"aa\" \"cc\""}})
{
"_id" : ObjectId("5965aa84aaf42d1c98dd95b0"), "title" : "aa bb cc", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
> db.col_7.find({$text:{$search:
"aa bb"}},{score:{$meta:"textScore"}}).sort({score:{$meta:"textScore"}})
{
"_id" : ObjectId("5965aedfaaf42d1c98dd95b2"), "title" : "aa bb", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》", "score" : 1.5 }
{
"_id" : ObjectId("5965aa84aaf42d1c98dd95b0"), "title" : "aa bb cc", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》", "score" : 1.3333333333333333 }
> db.col_7.dropIndexes()
> db.col_7.createIndex({
"author": "text"}))
> db.col_7.find({$text:{$search:
"小明"}})})
>
> db.col_7.find({$text:{$search:
"白小明"}})
{
"_id" : ObjectId("5965aa84aaf42d1c98dd95b0"), "title" : "aa bb cc", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
{
"_id" : ObjectId("5965aa8faaf42d1c98dd95b1"), "title" : "abc def", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
{
"_id" : ObjectId("5965aedfaaf42d1c98dd95b2"), "title" : "aa bb", "author" : "白小明", "article" : "这是白小明的一篇文章，标题《aa bb cc》" }
|
地理位置索引
查看最近的点
MongoDB - 聚合
==分组计算==
MongoDB 中聚合主要用于处理数据(如平均值,求和等)，并返回计算后的数据结果。相似sql语句中的 count(*)。
aggregate() 方法
|
1
|
db
.col_name.aggregate(AGGREGATE_OPERATION)
|
下表展现了一些聚合的表达式:
实例
计算每一个做者所写的文章数
在下面的例子中，咱们经过字段by_user字段对数据进行分组，并计算by_user字段相同值的总和。
集合中的数据以下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
{
"_id" : ObjectId("5963b992a812aa05b9d2e765"),
"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("5963b9aaa812aa05b9d2e766"),
"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("5963b9bba812aa05b9d2e767"),
"title" : "Neo4j Overview",
"description" : "Neo4j is no sql database",
"by_user" : "Neo4j",
"url" : "http://www.neo4j.com",
"tags" : [
"neo4j",
"database",
"NoSQL"
],
"likes" : 750
}
|
使用aggregate()计算结果以下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
db.col_1.aggregate([{
$
group: {
_id:
"$by_user",
num_tutorial: {
$
sum: 1
}
}
}])
// 返回
{
"_id" : "Neo4j", "num_tutorial" : 1 }
{
"_id" : "runoob.com", "num_tutorial" : 2 }
// 以上实例相似sql语句
select by_user, count(*) from col_1 group by by_user
|
聚合管道
管道在Unix和Linux中通常用于将当前命令的输出结果做为下一个命令的参数。
MongoDB 的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操做是能够重复的。
表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。
聚合管道经常使用的几个操做：
- $project：修改输入文档的结构。能够用来重命名、增长或删除域，也能够用于建立计算结果以及嵌套文档。
- $match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操做。
- $limit：用来限制MongoDB聚合管道返回的文档数。
- $skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
- $unwind：将文档中的某一个数组类型字段拆分红多条，每条包含数组中的一个值。
- $group：将集合中的文档分组，可用于统计结果。
- $sort：将输入文档排序后输出。
- $geoNear：输出接近某一地理位置的有序文档。
实例
$project 实例
0 为不显示，1为显示，默认状况下 _id 字段是 1
|
1
2
3
4
5
6
7
8
9
10
11
12
|
db.articles.aggregate({
$project: {
_id:
0,
title:
1,
by_user:
1,
}
});
// 返回
{
"title" : "MongoDB Overview", "by_user" : "runoob.com" }
{
"title" : "NoSQL Overview", "by_user" : "runoob.com" }
{
"title" : "Neo4j Overview", "by_user" : "Neo4j" }
|
$match 实例
$match 用于获取分数大于70小于或等于90记录，而后将符合条件的记录送到下一阶段$group管道操做符进行处理。
|
1
2
3
4
5
6
7
|
db.articles.aggregate([
{ $match: { score: { $gt:
70, $lte: 90 } } },
{ $group: { _id: null, count: { $sum:
1 } } }
]);
// 返回
{
"_id" : null, "count" : 1 }
|
$skip 实例
通过 $skip 管道操做符处理后，前2个文档被”过滤”掉。
|
1
|
db
.col_1.aggregate({ $skip: 2 });
|
MongoDB - 复制
MongoDB 复制（副本集）是==将数据同步在多个服务器==的过程。
复制提供了数据的冗余备份，并在多个服务器上存储数据副本，提升了数据的可用性， 并能够保证数据的安全性。
特色：
- 保障数据的安全性
- 数据高可用性 (24*7)
- 灾难恢复，复制容许您从硬件故障和服务中断中恢复数据。
- 无需停机维护（如备份，重建索引，压缩）
-
分布式读取数据
-
N 个节点的集群
- 任何节点可做为主节点
- 全部写入操做都在主节点上
- 自动故障转移
- 自动恢复
复制原理
mongodb 的复制至少须要两个节点。
- 其中一个是==主节点==，负责处理客户端请求，
- 其他的都是==从节点==，负责复制主节点上的数据。
mongodb各个节点常见的搭配方式为：一主一从、一主多从。
主节点记录在其上的全部操做oplog，从节点按期轮询主节点获取这些操做，而后对本身的数据副本执行这些操做，从而保证从节点的数据与主节点一致。
复制设置
- 关闭正在运行的MongoDB服务器。
如今咱们经过指定 –replSet 选项来启动mongoDB
|
1
|
mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"
|
实例：
下面实例会启动一个名为rs0的MongoDB实例，其端口号为27017。
启动后打开命令提示框并链接上mongoDB服务。
在Mongo客户端使用命令rs.initiate()来启动一个新的副本集。
咱们可使用rs.conf()来查看副本集的配置
查看副本集状态使用 rs.status() 命令
|
1
|
mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0
|
副本集添加成员
添加副本集的成员，咱们须要使用多条服务器来启动mongo服务。
进入Mongo客户端，并使用rs.add()方法来添加副本集的成员。
|
1
|
rs.add(HOST_NAME:PORT)
|
实例：
假设你已经启动了一个名为 mongod1.net，端口号为27017的Mongo服务。
在客户端命令窗口使用rs.add() 命令将其添加到副本集中，命令以下所示：
|
1
|
rs.add("mongod1.net:27017")
|
MongoDB 中你只能经过主节点将Mongo服务添加到副本集中， 判断当前运行的Mongo服务是否为主节点可使用命令
|
1
|
db.isMaster()
|
MongoDB的副本集与咱们常见的主从有所不一样，主从在主机宕机后全部服务将中止，而副本集在主机宕机后，副本会接管主节点成为主节点，不会出现宕机的状况。
MongoDB - 分片
当MongoDB存储海量的数据时，==一台机器可能不足以存储数据==，也可能不足以提供可接受的读写吞吐量。这时，咱们就能够经过在多台机器上分割数据，使得数据库系统能存储和处理更多的数据。
为何使用分片？
- 复制全部的写入操做到主节点
- 延迟的敏感数据会在主节点查询
- 单个副本集限制在12个节点
- 当请求量巨大时会出现内存不足。
- 本地磁盘不足
- 垂直扩展价格昂贵
分片集群结构
三个主要组件：
- Shard: 用于存储实际的数据块，实际生产环境中一个shard server角色可由几台机器组个一个replica set承担，防止主机单点故障
- Config Server: mongod实例，存储了整个 ClusterMetadata，其中包括 chunk信息。
- Query Routers: 前端路由，客户端由此接入，且让整个集群看上去像单一数据库，前端应用能够透明使用。
MongoDB - 监控
监控能够了解 MongoDB 的==运行状况==及==性能==
MongoDB中提供了 mongostat 和 mongotop 两个命令来监控MongoDB的运行状况。
mongostat
它会间隔固定时间获取 mongodb 的当前运行状态，并输出。
若是你发现数据库忽然变慢或者有其余问题的话，你第一手的操做就考虑采用 mongostat 来查看 mongo 的状态。
|
1
|
mongostat
|
mongotop
mongotop用来跟踪MongoDB的实例，提供每一个集合的统计数据。默认状况下，mongotop每一秒刷新一次。
|
1
|
mongotop
|
输出结果字段说明：
- ns：包含数据库命名空间，后者结合了数据库名称和集合。
- db：包含数据库的名称。名为 . 的数据库针对全局锁定，而非特定数据库。
- total：mongod花费的时间工做在这个命名空间提供总额。
- read：提供了大量的时间，这mongod花费在执行读操做，在此命名空间。
- write：提供这个命名空间进行写操做，这mongod花了大量的时间。
等待的时间长度，以秒为单位，默认 1s
|
1
|
mongotop
10
|
报告每一个数据库的锁的使用
|
1
|
mongotop
--locks
|
MongoDB - 备份与恢复
mongodump
在Mongodb中咱们使用 mongodump 命令来备份MongoDB数据。
该命令能够导出全部数据到指定目录中。
mongodump命令能够经过参数指定导出的数据量级转存的服务器。
|
1
2
3
4
5
|
mongodump -h dbhost -d dbname -o dbdirectory
-h：MongDB所在服务器地址，例如：127.0.0.1，固然也能够指定端口号：127.0.0.1:27017
-d：须要备份的数据库实例，例如：test
-o：备份的数据存放位置，例如：c:\data\dump，固然该目录须要提早创建，在备份完成后，系统自动在dump目录下创建一个test目录，这个目录里面存放该数据库实例的备份数据。
|
实例
备份 mongodb_study 数据库中的全部集合到 E:\MongoDB\dump
|
1
|
mongodump -h 127.0.0.1 -d mongodb_study -o E:\MongoDB\dump
|
不带任何参数，即在当前目录下备份全部数据库实例
|
1
|
mongodump
|
备份全部MongoDB数据
|
1
2
3
4
|
mongodump
--host HOST_NAME --port PORT_NUMBER
// 如
mongodump
--host w3cschool.cc --port 27017
|
备份指定数据库的集合
|
1
2
3
4
|
mongodump
--collection COLLECTION_NAME --db DB_NAME
// 如
mongodump
--collection mycol --db test
|
mongorestore
在Mongodb中咱们使用 mongorestore 命令来恢复MongoDB数据。
|
1
2
3
4
5
6
7
|
mongorestore -h <hostname><:port> -d dbname <path>
-
-host <:port>, -h <:port>：MongoDB所在服务器地址，默认为： localhost:27017
-
-db , -d ：须要恢复的数据库实例，例如：test，固然这个名称也能够和备份时候的不同，好比test2
-
-drop：恢复的时候，先删除当前数据，而后恢复备份的数据。就是说，恢复后，备份后添加修改的数据都会被删除，慎用哦！
<path>：mongorestore 最后的一个参数，设置备份数据所在位置，例如：c:\data\dump\test。你不能同时指定 <path> 和 --dir 选项，--dir也能够设置备份目录。
-
-dir：指定备份的目录，你不能同时指定 <path> 和 --dir 选项。
|
实例
恢复存放在 E:\MongoDB\dump 中的数据库 mongodb_study，恢复先后的数据库名没必要相同
|
1
|
mongorestore -h localhost /db mongodb_study /dir E:
\MongoDB\dump\mongodb_study
|
Node.js 链接 MongoDB
与 MySQL 不一样的是 MongoDB 会自动建立数据库和集合，因此使用前咱们不须要手动去建立。
安装驱动：npm install mongodb
运行 node：node connect
实例
connect.js
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
const MongoClient = require('mongodb').MongoClient;
// 自动建立数据库 runoob
let mongoConnect = 'mongodb://localhost:27017/runoob';
// 插入数据，插入到数据库 runoob 的 site 集合中
let insertData = function(db, callback) {
// 自动建立集合 site
let collection = db.collection('site');
// 插入文档
let data = [{
"name": "菜鸟教程",
"url": "www.runoob.com"
}, {
"name": "菜鸟工具",
"url": "c.runoob.com"
}];
collection.insert(data,
function(err, result) {
if (err) {
console.log('Error:' + err);
return;
}
callback(result);
});
};
// 删除数据，删除全部 name 为 "菜鸟工具" 的文档
let deleteData = function(db, callback) {
let collection = db.collection('site');
let whereStr = {
"name": "菜鸟工具"
};
collection.remove(whereStr,
function(err, result) {
if (err) {
console.log('Error:' + err);
return;
}
callback(result);
});
};
// 修改数据，将因此 name 为 "菜鸟教程" 的 url 改成 https://www.runoob.com
let updateData = function(db, callback) {
let collection = db.collection('site');
let whereStr = {
"name": "菜鸟教程"
};
let updateStr = {
$set: {
"url": "https://www.runoob.com"
}
};
collection.update(whereStr, updateStr, {
multi: true
},
function(err, result) {
if (err) {
console.log('Error:' + err);
return;
}
callback(result);
});
};
// 查询数据，查询 name 为 "菜鸟教程" 的数据
let selectData = function(db, callback) {
let collection = db.collection('site');
let whereStr = {
"name": '菜鸟教程'
};
collection.find(whereStr).toArray(
function(err, result) {
if (err) {
console.log('Error:' + err);
return;
}
callback(result);
});
};
MongoClient.connect(mongoConnect,
function(err, db) {
console.log("链接成功！");
insertData(db,
function(result) {
console.log("插入数据成功！");
console.log(result);
db.close();
});
deleteData(db,
function(result) {
console.log("删除数据成功！");
console.log(result);
db.close();
});
updateData(db,
function(result) {
console.log("修改数据成功！");
console.log(result);
db.close();
});
selectData(db,
function(result) {
console.log("查询数据成功！");
console.log(result);
db.close();
});
});
|
mongoose
Mongoose学习参考文档——基础篇：https://cnodejs.org/topic/504b4924e2b84515770103dd
mongoose学习笔记：https://cnodejs.org/topic/58b911997872ea0864fee313
mongoose学习文档：http://www.cnblogs.com/y-yxh/p/5689555.html
Nodejs学习笔记（十四）— Mongoose介绍和入门：http://www.cnblogs.com/zhongweiv/p/mongoose.html
Mongoose全面理解：http://www.cnblogs.com/jayruan/p/5123754.html
Node.js 有针对 MongoDB 的数据库驱动：mongodb。你可使用 npm install mongodb 来安装。不过直接使用 mongodb 模块虽然强大而灵活，但有些繁琐，我就使用 mongoose 吧。
Mongoose 基于nodejs、构建在 mongodb 之上，使用 javascript 编程，是==链接 mongodb 数据库的软件包==，使mongodb的文档数据模型变的优雅起来，方便对mongodb文档型数据库的链接和增删改查等常规数据操做。
mongoose 是当前使用 mean（mongodb express angularjs nodejs）全栈开发必用的链接数据库软件包。
==mongoose ，提供了Schema、Model 和 Document 对象，用起来更为方便。== 另外，mongoose 还有 Query 和 Aggregate 对象：Query 实现查询、Aggregate 实现聚合
mongoose 三个重要概念
Schema、Model、Entity 的关系：Schema生成Model，Model创造Entity，Model和Entity均可对数据库操做形成影响，但Model比Entity更具操做性。
1. Schema 模式
Schema 对象定义==文档结构==，能够定义字段、类型、惟一性、索引、验证等。
Schema 不只定义了文档结构和使用性能，还能够有扩展插件、实例方法、静态方法、复合索引、文档生命周期钩子
|
1
2
3
4
5
|
// new mongoose.Schema() 中传入一个 JSON 对象，定义属性和属性类型
var BlogSchema = new mongoose.Schema({
title:
String,
author:
String
});
|
有的时候，咱们创造的 Schema 不只要为后面的 Model 和 Entity 提供公共的属性，还要提供公共的方法。
2. Model 模型
Model 对象表示集合中的全部文档
由 Schema 发布生成的模型，具备抽象属性和行为的数据库操做对
3. Document 文档
Document 可等同于 Entity
由 Model 建立的实体，他的操做也会影响数据库
使用
- 定义一个 Schema 模式
- 将该 Schema 发布为 Model
- 用 Model 建立 Entity
- Entity 是具备具体的数据库操做 CRUD 的
mongoose 的 connection 对象定义了一些事件，好比 connected open close error 等，咱们能够监听这些事件。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
const mongoose = require('mongoose');
let db = mongoose.connect('mongodb://127.0.0.1:27017/test');
db.connection.on(
'error', console.error.bind(console, '数据库链接失败：'));
db.connection.once(
'open', function() {
console.log('数据库链接成功！');
// 定义一个 Schema 模式
// new Schema() 中传入一个 JSON 对象，定义属性和属性类型
let PersonSchema = new mongoose.Schema({
name: {
type: String,
unique: true
},
password: String
});
// 将该 Schema 发布为 Model
let PersonModel = mongoose.model('col_1', PersonSchema);
// 拿到了 Model 对象，就能够执行增删改查等操做了
// 若是要执行查询，须要依赖 Model，固然 Entity 也是能够作到的
PersonModel.find(
function(err, result) {
// 查询到的全部person
});
// 用 Model 建立 Entity
let personEntity = new PersonModel({
name: 'Krouky',
password: '10086'
});
// Entity 是具备具体的数据库操做 CRUD 的
// 执行完成后，数据库就有该数据了
personEntity.save(
function(err, result) {
if (err) {
console.log(err);
}
else {
console.log(`${result} saved!`);
}
});
});
|