什么是MongoDB
基于分布式文件存储的数据库。由 C++ 语言编写。MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。
主要特点
-
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安装简单。
MongoDB 工具
监控
- MongoDB提供了网络和系统监控工具Munin，它作为一个插件应用于MongoDB中。
- Gangila是MongoDB高性能的系统监视的工具，它作为一个插件应用于MongoDB中。
- 基于图形界面的开源工具 Cacti, 用于查看CPU负载, 网络带宽利用率,它也提供了一个应用于监控 MongoDB 的插件。
GUI
- Fang of Mongo – 网页式,由Django和jQuery所构成。
- Futon4Mongo – 一个CouchDB Futon web的mongodb山寨版。
- Mongo3 – Ruby写成。
- MongoHub – 适用于OSX的应用程序。
- Opricot – 一个基于浏览器的MongoDB控制台, 由PHP撰写而成。
- Database Master — Windows的mongodb管理工具
- RockMongo — 最好的PHP语言的MongoDB管理工具，轻量级, 支持多国语言.
Linux平台安装MongoDB
安装前我们需要安装各个 Linux 平台依赖包。
Red Hat/CentOS：
sudo yum install libcurl openssl
Ubuntu 18.04 LTS (“Bionic”)/Debian 10 “Buster”：
sudo apt-get install libcurl4 openssl
Ubuntu 16.04 LTS (“Xenial”)/Debian 9 “Stretch”：
sudo apt-get install libcurl3 openssl
下载完安装包，并解压 tgz
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-ubuntu1604-4.2.8.tgz # 下载
tar -zxvf mongodb-linux-x86_64-ubuntu1604-4.2.8.tgz # 解压
mv mongodb-src-r4.2.8 /usr/local/mongodb4 # 将解压包拷贝到指定目录
MongoDB 的可执行文件位于 bin 目录下，所以可以将其添加到 PATH 路径中：
export PATH=/usr/local/mongodb4/bin:$PATH
创建数据库目录
- 数据存储目录：/var/lib/mongodb
- 日志文件目录：/var/log/mongodb
sudo mkdir -p /var/lib/mongo
sudo mkdir -p /var/log/mongodb
sudo chown 'whoami' /var/lib/mongo # 设置权限
sudo chown 'whoami' /var/log/mongodb # 设置权限
启动 Mongodb 服务：
mongod --dbpath /var/lib/mongo --logpath /var/log/mongodb/mongod.log --fork
MongoDB 后台管理 Shell
cd /usr/local/mongodb4/bin
./mongo
MongoDB shell 来连接 Mongodb 服务
mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]
- mongodb:// 这是固定的格式，必须要指定。
- username:password@ 可选项，如果设置，在连接数据库服务器之后，驱动都会尝试登录这个数据库
- host1 必须的指定至少一个host, host1 是这个URI唯一要填写的。它指定了要连接服务器的地址。如果要连接复制集，请指定多个主机地址。
- portX 可选的指定端口，如果不填，默认为27017
- /database 如果指定username:password@，连接并验证登录指定数据库。若不指定，默认打开 test 数据库。
- ?options 是连接选项。如果不使用/database，则前面需要加上/。所有连接选项都是键值对name=value，键值对之间通过&或;（分号）隔开
标准的连接格式包含了多个选项(options)，如下所示：
| 选项 | 描述 |
|---|---|
| replicaSet=name | 验证replica set的名称。 Impliesconnect=replicaSet. |
| slaveOk=true/false | true:在connect=direct模式下，驱动会连接第一台机器，即使这台服务器不是主。在connect=replicaSet模式下，驱动会发送所有的写请求到主并且把读取操作分布在其他从服务器。false: 在 connect=direct模式下，驱动会自动找寻主服务器. 在connect=replicaSet 模式下，驱动仅仅连接主服务器，并且所有的读写命令都连接到主服务器。 |
| safe=true/false | true: 在执行更新操作之后，驱动都会发送getLastError命令来确保更新成功。(还要参考 wtimeoutMS).false: 在每次更新之后，驱动不会发送getLastError来确保更新成功。 |
| w=n | 驱动添加 { w : n } 到getLastError命令. 应用于safe=true。 |
| wtimeoutMS=ms | 驱动添加 { wtimeout : ms } 到 getlasterror 命令. 应用于 safe=true. |
| fsync=true/false | true: 驱动添加 { fsync : true } 到 getlasterror 命令.应用于 safe=true.false: 驱动不会添加到getLastError命令中。 |
| journal=true/false | 如果设置为 true, 同步到 journal (在提交到数据库前写入到实体中). 应用于 safe=true |
| connectTimeoutMS=ms | 可以打开连接的时间。 |
| socketTimeoutMS=ms | 发送和接受sockets的时间。 |
停止 mongodb
第一种
mongod --dbpath /var/lib/mongo --logpath /var/log/mongodb/mongod.log --shutdown
第二种
use admin
db.shutdownServer()
MongoDB 概念解析
| SQL术语/概念 | MongoDB术语/概念 | 解释/说明 |
|---|---|---|
| database | database | 数据库 |
| table | collection | 数据库表/集合 |
| row | document | 数据记录行/文档 |
| column | field | 数据字段/域 |
| index | index | 索引 |
| table joins | 表连接,MongoDB不支持 | |
| primary key | primary key | 主键,MongoDB自动将_id字段设置为主键 |
数据库
显示所有数据库的列表
show dbs
显示当前数据库对象或集合
db
连接到一个指定的数据库
use local
数据库命名规则
- 不能是空字符串（“”)。
- 不得含有’ '（空格)、.、$、/、\和\0 (空字符)。
- 应全部小写。
- 最多64字节。
保留数据库
- admin： 从权限的角度来看，这是"root"数据库。要是将一个用户添加到这个数据库，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器。
- local: 这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合
- config: 当Mongo用于分片设置时，config数据库在内部使用，用于保存分片的相关信息。
集合
集合存在于数据库中，集合没有固定的结构，这意味着你在对集合可以插入不同格式和类型的数据，但通常情况下我们插入集合的数据都会有一定的关联性。
合法的集合名
- 集合名不能是空字符串""。
- 集合名不能含有\0字符（空字符)，这个字符表示集合名的结尾。
- 集合名不能以"system."开头，这是为系统集合保留的前缀。
- 用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含，这是因为某些系统生成的集合中包含该字符。除非你要访问这种系统创建的集合，否则千万不要在名字里出现$。
capped collections
Capped collections 就是固定大小的collection。它有很高的性能以及队列过期的特性(过期按照插入的顺序). 有点和 “RRD” 概念类似。
db.createCollection("mycoll", {capped:true, size:100000})
- 在 capped collection 中，你能添加新的对象。
- 能进行更新，然而，对象不会增加存储空间。如果增加，更新就会失败 。
使用 Capped Collection 不能删除一个文档，可以使用 drop() 方法删除 collection 所有的行。 - 删除之后，你必须显式的重新创建这个 collection。
- 在32bit机器中，capped collection 最大存储为 1e9( 1X10^9)个字节。
文档(Document)
RDBMS 与 MongoDB 对应的术语
| RDBMS | MongoDB | |
|---|---|---|
| 数据库 | 数据库 | |
| 表格 | 集合 | |
| 行 | 文档 | |
| 列 | 字段 | |
| 表联合 | 嵌入文档 | |
| 主键 | MongoDB 提供了 key 为 _id | |
| 数据库服务和客户端 | ||
| Mysqld/Oracle | mongod | |
| mysql/sqlplus | mongo |
需要注意的是：
1. 文档中的键/值对是有序的。
2. 文档中的值不仅可以是在双引号里面的字符串，还可以是其他几种数据类型（甚至可以是整个嵌入的文档)。
3. MongoDB区分类型和大小写。
4. MongoDB的文档不能有重复的键。
5. 文档的键是字符串。除了少数例外情况，键可以使用任意UTF-8字符。
文档键命名规范：
- 键不能含有\0 (空字符)。这个字符用来表示键的结尾。
- 和$有特别的意义，只有在特定环境下才能使用。
- 以下划线"_"开头的键是保留的(不是严格要求的)。
元数据
数据库的信息是存储在集合中。它们使用了系统的命名空间：
<dbname＞.system.*
| 集合命名空间 | 描述 |
|---|---|
| dbname.system.namespaces | 列出所有名字空间。 |
| dbname.system.indexes | 列出所有索引 |
| dbname.system.profile | 包含数据库概要(profile)信息。 |
| dbname.system.users | 列出所有可访问数据库的用户。 |
| dbname.local.sources | 包含复制对端（slave）的服务器信息和状态。 |
MongoDB 数据类型
| 数据类型 | 描述 |
|---|---|
| String | 字符串。存储数据常用的数据类型。在 MongoDB 中，UTF-8 编码的字符串才是合法的。 |
| Integer | 整型数值。用于存储数值。根据你所采用的服务器，可分为 32 位或 64 位。 |
| Boolean | 布尔值。用于存储布尔值（真/假）。 |
| Double | 双精度浮点值。用于存储浮点值。 |
| Min/Max keys | 将一个值与 BSON（二进制的 JSON）元素的最低值和最高值相对比。 |
| Array | 用于将数组或列表或多个值存储为一个键。 |
| Timestamp | 时间戳。记录文档修改或添加的具体时间。 |
| Object | 用于内嵌文档。 |
| Null | 用于创建空值。 |
| Symbol | 符号。该数据类型基本上等同于字符串类型，但不同的是，它一般用于采用特殊符号类型的语言。 |
| Date | 日期时间。用 UNIX 时间格式来存储当前日期或时间。你可以指定自己的日期时间：创建 Date 对象，传入年月日信息。 |
| Object ID | 对象 ID。用于创建文档的 ID。 |
| Binary Data | 二进制数据。用于存储二进制数据。 |
| Code | 代码类型。用于在文档中存储 JavaScript 代码。 |
| Regular expression | 正则表达式类型。用于存储正则表达式。 |
ObjectId
ObjectId 类似唯一主键，可以很快的去生成和排序，包含 12 bytes，含义是：
- 前 4 个字节表示创建 unix 时间戳,格林尼治时间 UTC 时间，比北京时间晚了 8 个小时
- 接下来的 3 个字节是机器标识码
- 紧接的两个字节由进程 id 组成 PID
- 最后三个字节是随机数
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11
时间戳 | 机器 | PID | 计数器 |
通过 getTimestamp 函数来获取文档的创建时间
var newObject = ObjectId()
newObject.getTimestamp()
ObjectId 转为字符串
newObject.str
字符串
BSON 字符串都是 UTF-8 编码。
时间戳
BSON 有一个特殊的时间戳类型用于 MongoDB 内部使用，与普通的 日期 类型不相关。 时间戳值是一个 64 位的值。其中：前32位是一个 time_t 值（与Unix新纪元相差的秒数）后32位是在某秒中操作的一个递增的序数
日期
表示当前距离 Unix新纪元（1970年1月1日）的毫秒数。日期类型是有符号的, 负数表示 1970 年之前的日期。
> var mydate1 = new Date() //格林尼治时间
> mydate1
ISODate("2018-03-04T14:58:51.233Z")
> typeof mydate1
object
> var mydate2 = ISODate() //格林尼治时间
> mydate2
ISODate("2018-03-04T15:00:45.479Z")
> typeof mydate2
object
返回一个时间类型的字符串：
> var mydate1str = mydate1.toString()
> mydate1str
Sun Mar 04 2018 14:58:51 GMT+0000 (UTC)
> typeof mydate1str
string
或者
> Date()
Sun Mar 04 2018 15:02:59 GMT+0000 (UTC)
语法
创建数据库，插入数据后才显示
use <DATABASE_NAME>
查看所有数据库
show dbs
删除当前数据库
db.dropDatabase()
创建集合
db.createCollection(<name>, <options>)
参数说明：
- name: 要创建的集合名称
- options: 可选参数, 指定有关内存大小及索引的选项
options 可以是如下参数：
| 字段 | 类型 | 描述 |
|---|---|---|
| capped | 布尔 | （可选）如果为 true，则创建固定集合。固定集合是指有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。当该值为 true 时，必须指定 size 参数。 |
| autoIndexId | 布尔 | 3.2 之后不再支持该参数。（可选）如为 true，自动在 _id 字段创建索引。默认为 false。 |
| size | 数值 | （可选）为固定集合指定一个最大值，即字节数。如果 capped 为 true，也需要指定该字段。 |
| max | 数值 | （可选）指定固定集合中包含文档的最大数量。 |
在插入文档时，MongoDB 首先检查固定集合的 size 字段，然后检查 max 字段。
查看已有集合
show collections 或 show tables
删除某集合
db.<collection>.drop()
插入文档
db.<COLLECTION_NAME>.insert(<document>) 或 db.<COLLECTION_NAME>.save(<document>)
- save()：如果 _id 主键存在则更新数据，如果不存在就插入数据。该方法新版本中已废弃，可以使用 db..insertOne() 或 db..replaceOne() 来代替。
- insert(): 若插入的数据主键已经存在，则会抛org.springframework.dao.DuplicateKeyException 异常，提示主键重复，不保存当前数据。
db.<collection>.insertOne()
db.<collection>.insertOne(
<document>,
{
writeConcern: <document>
}
)
db.<collection>.insertMany()
db.<collection>.insertMany(
[ <document 1> , <document 2>, ... ],
{
writeConcern: <document>,
ordered: <boolean>
}
)
参数说明:
- document：要写入的文档。
- writeConcern：写入策略，默认为 1，即要求确认写操作，0 是不要求。
- ordered：指定是否按顺序写入，默认 true，按顺序写入。
实例
db.col.insert({title: 'MongoDB 教程',
description: 'MongoDB 是一个 Nosql 数据库',
by: '菜鸟教程',
url: 'http://www.runoob.com',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 100
})
更新文档
update() 方法
db.<collection>.update(
<query>,
<update>,
{
upsert: <boolean>,
multi: <boolean>,
writeConcern: <document>
}
)
参数说明：
- query : update的查询条件，类似sql update查询内where后面的。
- update : update的对象和一些更新的操作符（如
$,$inc…）等，也可以理解为sql update查询内set后面的 - upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
- multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
- writeConcern :可选，抛出异常的级别。
实例
db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}})
save() 方法
save() 方法通过传入的文档来替换已有文档，_id 主键存在就更新，不存在就插入。
db.<collection>.save(
<document>,
{
writeConcern: <document>
}
)
参数说明：
- document : 文档数据。
- writeConcern :可选，抛出异常的级别。
抛出异常类型
- WriteConcern.NONE:没有异常抛出
- WriteConcern.NORMAL:仅抛出网络错误异常，没有服务器错误异常
- WriteConcern.SAFE:抛出网络错误异常、服务器错误异常；并等待服务器完成写操作。
- WriteConcern.MAJORITY: 抛出网络错误异常、服务器错误异常；并等待一个主服务器完成写操作。
- WriteConcern.FSYNC_SAFE: 抛出网络错误异常、服务器错误异常；写操作等待服务器将数据刷新到磁盘。
- WriteConcern.JOURNAL_SAFE:抛出网络错误异常、服务器错误异常；写操作等待服务器提交到磁盘的日志文件。
- WriteConcern.REPLICAS_SAFE:抛出网络错误异常、服务器错误异常；等待至少2台服务器完成写操作。
删除某文档
remove()
db.<collection>.remove(
<query>,
{
justOne: <boolean>,
writeConcern: <document>
}
)
参数说明：
- query :（可选）删除的文档的条件。
- justOne : （可选）如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，则删除所有匹配条件的文档。
- writeConcern :（可选）抛出异常的级别。
实例
删除所有文档
db.col.remove({})
移除 集合col中title 为 ‘MongoDB 教程‘ 的文档：
db.col.remove({'title':'MongoDB 教程'})
deleteOne()
删除 status 等于 D的一个文档：：
db.inventory.deleteOne( { status: "D" } )
deleteMany()
删除 status 等于 A 的全部文档：
db.inventory.deleteMany({ status : "A" })
查询文档
db.<collection>.find(<query>,< projection>)[.pretty()]
-
query ：可选，使用查询操作符指定查询条件
-
projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。
若不指定 projection，则默认返回所有键，指定 projection 格式如下，有两种模式db.<collection>.find(<query>, {title: 1, by: 1}) // inclusion模式 指定返回的键，不返回其他键 db.<collection>.find(<query>, {title: 0, by: 0}) // exclusion模式 指定不返回的键,返回其他键_id 键默认返回，需要主动指定 _id:0 才会隐藏
两种模式不可混用（因为这样的话无法推断其他键是否应返回）db.<collection>.find(<query>, {title: 1, by: 0}) // 错误只能全1或全0，除了在inclusion模式时可以指定_id为0
-
pretty() 方法以格式化的方式来显示所有文档。
AND 条件
db.col.find({key1:value1, key2:value2}).pretty()
OR 条件
db.col.find(
{
$or: [
{key1: value1}, {key2:value2}
]
}
).pretty()
条件操作符
- (>) 大于 - $gt
- (<) 小于 - $lt
- (>=) 大于等于 - $gte
- (<= ) 小于等于 - $lte
大于操作符 - $gt
db.col.find({likes : {$gt : 100}})
大于等于操作符 - $gte
db.col.find({likes : {$gte : 100}})
小于操作符 - $lt
db.col.find({likes : {$lt : 150}})
小于等于操作符 - $lte
db.col.find({likes : {$lte : 150}})
大于100，小于 200 的数据
db.col.find({likes : {$lt :200, $gt : 100}})
模糊查询
查询 title 包含”教“字的文档：
db.col.find({title:/教/})
查询 title 字段以”教“字开头的文档：
db.col.find({title:/^教/})
查询 titl e字段以”教“字结尾的文档：
db.col.find({title:/教$/})
$type 操作符
| 类型 | 数字 |
|---|---|
| Double | 1 |
| String | 2 |
| Object | 3 |
| Array | 4 |
| Binary data | 5 |
| Undefined | 6 |
| Object id | 7 |
| Boolean | 8 |
| Date | 9 |
| Null | 10 |
| Regula Expression Expression | 11 |
| JavaScript | 13 |
| Symbol | 14 |
| JavaScript (with scope) | 15 |
| 32-bit integer | 16 |
| Timestamp | 17 |
| 64-bit integer | 18 |
| Min key | 255 |
| Max key | 127 |
实例
如果想获取 ”col“ 集合中 title 为 String 的数据
db.col.find({"title" : {$type : 2}})
或
db.col.find({"title" : {$type : 'string'}})
Limit() 分页方法
db.<COLLECTION_NAME>.find().limit(<NUMBER>)
- NUMBER 指定从MongoDB中读取的记录条数。
Skip() 跳过记录方法
db.<COLLECTION_NAME>.find().skip(<NUMBER>)
- NUMBER 跳过的记录条数
sort() 排序方法
db.<COLLECTION_NAME>.find().sort({KEY:1})
- 1 为升序排列，而 -1 是用于降序排列
skip(), limilt(), sort()三个放在一起执行的时候，执行的顺序是先 sort(), 然后是 skip()，最后是显示的 limit()。
索引
创建索引
db.collection.createIndex(keys, options)
- Key 值为你要创建的索引字段，1 为指定按升序创建索引，如果你想按降序来创建索引指定为 -1 即可。
| Parameter | Type | Description |
|---|---|---|
| background | Boolean | 建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引，即增加 “background” 可选参数。 “background” 默认值为false。 |
| unique | Boolean | 建立的索引是否唯一。指定为true创建唯一索引。默认值为false. |
| name | string | 索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成一个索引名称 |
| dropDups | Boolean | 在建立唯一索引时是否删除重复记录,指定 true 创建唯一索引。默认值为 false. |
| sparse | Boolean | 对文档中不存在的字段数据不启用索引；这个参数需要特别注意，如果设置为true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 false. |
| expireAfterSeconds | integer | 指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间。 |
| v | index version | 索引的版本号。默认的索引版本取决于mongod创建索引时运行的版本。 |
| weights | document | 索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得分权重。 |
| default_language | string | 对于文本索引，该参数决定了停用词及词干和词器的规则的列表。 默认为英语 |
| language_override | string | 对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language，默认值为 language. |
实例
在后台创建索引：
db.values.createIndex({open: 1, close: 1}, {background: true})
查看集合索引
db.col.getIndexes()
查看集合索引大小
db.col.totalIndexSize()
删除集合所有索引
db.col.dropIndexes()
删除集合指定索引
db.col.dropIndex("索引名称")
聚合函数
aggregate() 方法
db.<COLLECTION_NAME>.aggregate(<AGGREGATE_OPERATION>)
实例
计算每个作者所写的文章数
db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
聚合的表达式:
| 表达式 | 描述 | 实例 |
|---|---|---|
| $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"}}}]) |
- $project：修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
$match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。- $limit：用来限制MongoDB聚合管道返回的文档数。
- $skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
- $unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。
- $group：将集合中的文档分组，可用于统计结果。
- $sort：将输入文档排序后输出。
- $geoNear：输出接近某一地理位置的有序文档。
实例
db.articles.aggregate( [
{ $match : { score : { $gt : 70, $lte : 90 } } },
{ $group: { _id: null, count: { $sum: 1 } } }
] );
$match用于获取分数大于70小于或等于90记录，然后将符合条件的记录送到下一阶段$group管道操作符进行处理。
复制原理
mongodb的复制至少需要两个节点。其中一个是主节点，负责处理客户端请求，其余的都是从节点，负责复制主节点上的数据。
mongodb各个节点常见的搭配方式为：一主一从、一主多从。
主节点记录在其上的所有操作oplog，从节点定期轮询主节点获取这些操作，然后对自己的数据副本执行这些操作，从而保证从节点的数据与主节点一致。
MongoDB复制结构图如下所示：
以上结构图中，客户端从主节点读取数据，在客户端写入数据到主节点时， 主节点与从节点进行数据交互保障数据的一致性。
副本集特征：
- N 个节点的集群
- 任何节点可作为主节点
- 所有写入操作都在主节点上
- 自动故障转移
- 自动恢复
MongoDB副本集设置
1、关闭正在运行的MongoDB服务器。
2、通过指定 --replSet 选项来启动mongoDB。
mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"
3、客户端使用命令rs.initiate()来启动一个新的副本集。
4、使用rs.conf()来查看副本集的配置
5、查看副本集状态使用 rs.status() 命令
副本集添加成员
rs.add(HOST_NAME:PORT)
只能通过主节点将Mongo服务添加到副本集中， 判断当前运行的Mongo服务是否为主节点可以使用命令db.isMaster() 。
主从在主机宕机后所有服务将停止，而副本集在主机宕机后，副本会接管主节点成为主节点，不会出现宕机的情况。
分片
为什么使用分片
- 复制所有的写入操作到主节点
- 延迟的敏感数据会在主节点查询
- 单个副本集限制在12个节点
- 当请求量巨大时会出现内存不足。
- 本地磁盘不足
- 垂直扩展价格昂贵
分片集群结构分布：
- Shard:用于存储实际的数据块，实际生产环境中一个shard server角色可由几台机器组个一个replica set承担，防止主机单点故障
- Config Server:mongod实例，存储了整个 ClusterMetadata，其中包括 chunk信息。
- Query Routers:前端路由，客户端由此接入，且让整个集群看上去像单一数据库，前端应用可以透明使用。
分片实例
分片结构端口分布如下：
- Shard Server 1：27020
- Shard Server 2：27021
- Shard Server 3：27022
- Shard Server 4：27023
- Config Server ：27100
- Route Process：40000
步骤一：启动Shard Server
[root@100 /]# mkdir -p /www/mongoDB/shard/s0
[root@100 /]# mkdir -p /www/mongoDB/shard/s1
[root@100 /]# mkdir -p /www/mongoDB/shard/s2
[root@100 /]# mkdir -p /www/mongoDB/shard/s3
[root@100 /]# mkdir -p /www/mongoDB/shard/log
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27020 --dbpath=/www/mongoDB/shard/s0 --logpath=/www/mongoDB/shard/log/s0.log --logappend --fork
....
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27023 --dbpath=/www/mongoDB/shard/s3 --logpath=/www/mongoDB/shard/log/s3.log --logappend --fork
步骤二： 启动Config Server
[root@100 /]# mkdir -p /www/mongoDB/shard/config
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27100 --dbpath=/www/mongoDB/shard/config --logpath=/www/mongoDB/shard/log/config.log --logappend --fork
**注意：**这里我们完全可以像启动普通mongodb服务一样启动，不需要添加—shardsvr和configsvr参数。因为这两个参数的作用就是改变启动端口的，所以我们自行指定了端口就可以。
步骤三： 启动Route Process
/usr/local/mongoDB/bin/mongos --port 40000 --configdb localhost:27100 --fork --logpath=/www/mongoDB/shard/log/route.log --chunkSize 500
mongos启动参数中，chunkSize这一项是用来指定chunk的大小的，单位是MB，默认大小为200MB.
步骤四： 配置Sharding
接下来，我们使用MongoDB Shell登录到mongos，添加Shard节点
[root@100 shard]# /usr/local/mongoDB/bin/mongo admin --port 40000
MongoDB shell version: 2.0.7
connecting to: 127.0.0.1:40000/admin
mongos> db.runCommand({ addshard:"localhost:27020" })
{ "shardAdded" : "shard0000", "ok" : 1 }
......
mongos> db.runCommand({ addshard:"localhost:27029" })
{ "shardAdded" : "shard0009", "ok" : 1 }
mongos> db.runCommand({ enablesharding:"test" }) #设置分片存储的数据库
{ "ok" : 1 }
mongos> db.runCommand({ shardcollection: "test.log", key: { id:1,time:1}})
{ "collectionsharded" : "test.log", "ok" : 1 }
步骤五： 程序代码内无需太大更改，直接按照连接普通的mongo数据库那样，将数据库连接接入接口40000
备份与恢复
数据备份
mongodump -h dbhost --collection COLLECTION -d dbname -o dbdirectory
- h：MongoDB 所在服务器地址，例如：127.0.0.1，当然也可以指定端口号：127.0.0.1:27017
- -d：需要备份的数据库实例，例如：test
- -o：备份的数据存放位置，例如：c:\data\dump，当然该目录需要提前建立，在备份完成后，系统自动在dump目录下建立一个test目录，这个目录里面存放该数据库实例的备份数据。
- –collection:需要备份的集合
数据恢复
mongorestore -h <hostname><:port> -d dbname <path>
- —host <:port>, -h <:port>：MongoDB所在服务器地址，默认为： localhost:27017
- —db , -d ：需要恢复的数据库实例，例如：test，当然这个名称也可以和备份时候的不一样，比如test2
- —drop：恢复的时候，先删除当前数据，然后恢复备份的数据。就是说，恢复后，备份后添加修改的数据都会被删除，慎用哦！
-
：mongorestore 最后的一个参数，设置备份数据所在位置，例如：c:\data\dump\test。你不能同时指定 和 —dir 选项，—dir也可以设置备份目录。 - —dir：指定备份的目录，你不能同时指定
和 —dir 选项。
监控
mongostat 命令
间隔固定时间获取mongodb的当前运行状态，并输出。
D:\setup\mongodb\bin>mongostat
mongotop 命令
用来跟踪一个MongoDB的实例，查看哪些大量的时间花费在读取和写入数据。 mongotop提供每个集合的水平的统计数据。默认情况下，mongotop返回值的每一秒。
D:\set up\mongodb\bin>mongotop
带参数实例
E:\mongodb-win32-x86_64-2.2.1\bin>mongotop 10
后面的10是参数 ，可以不使用，等待的时间长度，以秒为单位，mongotop等待调用之间。通过的默认mongotop返回数据的每一秒。
E:\mongodb-win32-x86_64-2.2.1\bin>mongotop --locks
报告每个数据库的锁的使用中，使用mongotop - 锁
输出结果字段说明：
- ns：包含数据库命名空间，后者结合了数据库名称和集合。
- db：包含数据库的名称。名为 . 的数据库针对全局锁定，而非特定数据库。
- total：mongod花费的时间工作在这个命名空间提供总额。
- read：提供了大量的时间，这mongod花费在执行读操作，在此命名空间。
- write：提供这个命名空间进行写操作，这mongod花了大量的时间。
MongoDB Java
环境配置
检测是否安装了 MongoDB JDBC 驱动。
-
首先你必须下载mongo jar包，下载地址：https://mongodb.github.io/mongo-java-driver/, 请确保下载最新版本。
-
将 mongo-java-driver-3.2.2.jar （找到合适的版本）包含在你的 classpath 中。。
-
国内 mongodb-driver jar 下载地址：http://central.maven.org/maven2/org/mongodb/mongo-java-driver/
连接数据库
连接数据库的Java代码如下：
import java.util.ArrayList;
import java.util.List;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoDatabase;
public class MongoDBJDBC {
public static void main(String[] args){
try {
//连接到MongoDB服务 如果是远程连接可以替换“localhost”为服务器所在IP地址
//ServerAddress()两个参数分别为 服务器地址 和 端口
ServerAddress serverAddress = new ServerAddress("localhost",27017);
List<ServerAddress> addrs = new ArrayList<ServerAddress>();
addrs.add(serverAddress);
//MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码
MongoCredential credential = MongoCredential.createScramSha1Credential("username", "databaseName", "password".toCharArray());
List<MongoCredential> credentials = new ArrayList<MongoCredential>();
credentials.add(credential);
//通过连接认证获取MongoDB连接
MongoClient mongoClient = new MongoClient(addrs,credentials);
//连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("databaseName");
System.out.println("Connect to database successfully");
} catch (Exception e) {
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
}
}
}
编译运行程序并连接到数据库
$ javac -cp .:mongo-java-driver-3.2.2.jar MongoDBJDBC.java
$ java -cp .:mongo-java-driver-3.2.2.jar MongoDBJDBC
Connect to database successfully
Authentication: true
Java操作MongoDB数据库
import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;
public class MongoDBJDBC{
public static void main( String args[] ){
try{
// 连接到 mongodb 服务
MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
// 连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");
System.out.println("Connect to database successfully");
//创建集合mongoDatabase.createCollection("test");
System.out.println("集合创建成功");
//获取集合MongoCollection<Document> collection = mongoDatabase.getCollection("test");
System.out.println("集合 test 选择成功");
//插入文档
/**
* 1. 创建文档 org.bson.Document 参数为key-value的格式
* 2. 创建文档集合List<Document>
* 3. 将文档集合插入数据库集合中 mongoCollection.insertMany(List<Document>) 插入单个文档可以用 mongoCollection.insertOne(Document)
* */
Document document = new Document("title", "MongoDB").
append("description", "database").
append("likes", 100).
append("by", "Fly");
List<Document> documents = new ArrayList<Document>();
documents.add(document);
collection.insertMany(documents);
System.out.println("文档插入成功");
//检索所有文档
/**
* 1. 获取迭代器FindIterable<Document>
* 2. 获取游标MongoCursor<Document>
* 3. 通过游标遍历检索出的文档集合
* */
FindIterable<Document> findIterable = collection.find();
MongoCursor<Document> mongoCursor =findIterable.iterator();
while(mongoCursor.hasNext()){
System.out.println(mongoCursor.next());
}
//更新文档 将文档中likes=100的文档修改为likes=200
collection.updateMany(Filters.eq("likes", 100), new Document("$set",new Document("likes",200)));
//检索查看结果
FindIterable<Document> findIterable = collection.find();
MongoCursor<Document> mongoCursor = findIterable.iterator();
while(mongoCursor.hasNext()){
System.out.println(mongoCursor.next());
}
//删除符合条件的第一个文档
collection.deleteOne(Filters.eq("likes", 200));
//删除所有符合条件的文档
collection.deleteMany (Filters.eq("likes", 200));
//检索查看结果
FindIterable<Document> findIterable = collection.find();
MongoCursor<Document> mongoCursor = findIterable.iterator();
while(mongoCursor.hasNext()){
System.out.println(mongoCursor.next());
}
}catch(Exception e){
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
}
}
}
关系
MongoDB 中的关系可以是：
- 1:1 (1对1)
- 1: N (1对多)
- N: 1 (多对1)
- N: N (多对多)
嵌入式关系
使用嵌入式方法，把用户地址嵌入到用户的文档中：
{
"_id":ObjectId("52ffc33cd85242f436000001"),
"contact": "987654321",
"dob": "01-01-1991",
"name": "Tom Benzamin",
"address": [
{
"building": "22 A, Indiana Apt",
"pincode": 123456,
"city": "Los Angeles",
"state": "California"
},
{
"building": "170 A, Acropolis Apt",
"pincode": 456789,
"city": "Chicago",
"state": "Illinois"
}]
}
查询用户的地址：
db.users.findOne({"name":"Tom Benzamin"},{"address":1})
注意：以上查询中 db 和 users 表示数据库和集合。这种数据结构的缺点是，如果用户和用户地址在不断增加，数据量不断变大，会影响读写性能。
引用式关系
把用户数据文档和用户地址数据文档分开，通过引用文档的 id 字段来建立关系
{
"_id":ObjectId("52ffc33cd85242f436000001"),
"contact": "987654321",
"dob": "01-01-1991",
"name": "Tom Benzamin",
"address_ids": [
ObjectId("52ffc4a5d85242602e000000"),
ObjectId("52ffc4a5d85242602e000001")
]
}
以上实例中，用户文档的 address_ids 字段包含用户地址的对象id（ObjectId）数组。
我们可以读取这些用户地址的对象id（ObjectId）来获取用户的详细地址信息。
这种方法需要两次查询，第一次查询用户地址的对象id（ObjectId），第二次通过查询的id获取用户的详细地址信息。
>var result = db.users.findOne({"name":"Tom Benzamin"},{"address_ids":1})
>var addresses = db.address.find({"_id":{"$in":result["address_ids"]}})
数据库引用
MongoDB 引用有两种：
- 手动引用（Manual References）
- DBRefs
使用 DBRefs
DBRef的形式：
{ $ref : , $id : , $db : }
三个字段表示的意义为：
- $ref：集合名称
- $id：引用的id
- $db:数据库名称，可选参数
以下实例中用户数据文档使用了 DBRef, 字段 address：
{
"_id":ObjectId("53402597d852426020000002"),
"address": {
"$ref": "address_home",
"$id": ObjectId("534009e4d852427820000002"),
"$db": "runoob"},
"contact": "987654321",
"dob": "01-01-1991",
"name": "Tom Benzamin"
}
address DBRef 字段指定了引用的地址文档是在 runoob 数据库下的 address_home 集合，id 为 534009e4d852427820000002。
通过指定 $ref 参数（address_home 集合）来查找集合中指定id的用户地址信息：
>var user = db.users.findOne({"name":"Tom Benzamin"})
>var dbRef = user.address
>db[dbRef.$ref].findOne({"_id":(dbRef.$id)})
覆盖索引查询
覆盖查询是以下的查询：
- 所有的查询字段是索引的一部分
- 所有的查询返回字段在同一个索引中
- 如果索引中不包括 _id 字段，_id在查询中会默认返回，可以在MongoDB的查询结果集中排除它来进行覆盖查询。
如果是以下的查询，不能使用覆盖索引查询：
- 所有索引字段是一个数组
- 所有索引字段是一个子文档
查询分析
常用函数有
- explain()
- hint()
使用 explain()
explain 操作提供了查询信息，使用索引及查询统计等。
>db.users.find({gender:"M"},{user_name:1,_id:0}).explain()
查询返回如下结果：
{
"cursor" : "BtreeCursor gender_1_user_name_1",
"isMultiKey" : false,
"n" : 1,
"nscannedObjects" : 0,
"nscanned" : 1,
"nscannedObjectsAllPlans" : 0,
"nscannedAllPlans" : 1,
"scanAndOrder" : false,
"indexOnly" : true,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 0,
"indexBounds" : {
"gender" : [
[
"M",
"M"
]
],
"user_name" : [
[
{
"$minElement" : 1
},
{
"$maxElement" : 1
}
]
]
}
}
结果集的字段：
- indexOnly: 字段为 true ，表示我们使用了索引。
- cursor：因为这个查询使用了索引，MongoDB 中索引存储在B树结构中，所以这是也使用了 BtreeCursor 类型的游标。如果没有使用索引，游标的类型是 BasicCursor。这个键还会给出你所使用的索引的名称，你通过这个名称可以查看当前数据库下的system.indexes集合（系统自动创建，由于存储索引信息，这个稍微会提到）来得到索引的详细信息。
- n：当前查询返回的文档数量。
- nscanned/nscannedObjects：表明当前这次查询一共扫描了集合中多少个文档，我们的目的是，让这个数值和返回文档的数量越接近越好。
- millis：当前查询所需时间，毫秒数。
- indexBounds：当前查询具体使用的索引。
使用 hint()
可以使用 hint 来强制 MongoDB 使用一个指定的索引。
>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1})
原子操作
mongodb不支持事务，所以，在你的项目中应用时，要注意这点。无论什么设计，都不要要求mongodb保证数据的完整性。
但是mongodb提供了许多原子操作，比如文档的保存，修改，删除等，都是原子操作。
book = {
_id: 123456789,
title: "MongoDB: The Definitive Guide",
author: [ "Kristina Chodorow", "Mike Dirolf" ],
published_date: ISODate("2010-09-24"),
pages: 216,
language: "English",
publisher_id: "oreilly",
available: 3,
checkout: [ { by: "joe", date: ISODate("2012-10-15") } ]
}
使用 db.collection.findAndModify() 方法来判断书籍是否可结算并更新新的结算信息。
db.books.findAndModify ( {
query: {
_id: 123456789,
available: { $gt: 0 }
},
update: {
$inc: { available: -1 },
$push: { checkout: { by: "abc", date: new Date() } }
}
} )
原子操作常用命令
$set
用来指定一个键并更新键值，若键不存在并创建。
{ $set : { field : value } }
$unset
用来删除一个键。
{ $unset : { field : 1} }
$inc
$inc可以对文档的某个值为数字型（只能为满足要求的数字）的键进行增减的操作。
{ $inc : { field : value } }
$push
用法：
{ $push : { field : value } }
把value追加到field里面去，field一定要是数组类型才行，如果field不存在，会新增一个数组类型加进去。
$pushAll
同$push,只是一次可以追加多个值到一个数组字段内。
{ $pushAll : { field : value_array } }
$pull
从数组field内删除一个等于value值。
{ $pull : { field : _value } }
$addToSet
增加一个值到数组内，而且只有当这个值不在数组内才增加。
$pop
删除数组的第一个或最后一个元素
{ $pop : { field : 1 } }
$rename
修改字段名称
{ $rename : { old_field_name : new_field_name } }
$bit
位操作，integer类型
{$bit : { field : {and : 5}}}
偏移操作符
> t.find() { "_id" : ObjectId("4b97e62bf1d8c7152c9ccb74"), "title" : "ABC", "comments" : [ { "by" : "joe", "votes" : 3 }, { "by" : "jane", "votes" : 7 } ] }
> t.update( {'comments.by':'joe'}, {$inc:{'comments.$.votes':1}}, false, true )
> t.find() { "_id" : ObjectId("4b97e62bf1d8c7152c9ccb74"), "title" : "ABC", "comments" : [ { "by" : "joe", "votes" : 4 }, { "by" : "jane", "votes" : 7 } ] }
高级索引
users:
{
"address": {
"city": "Los Angeles",
"state": "California",
"pincode": "123"
},
"tags": [
"music",
"cricket",
"blogs"
],
"name": "Tom Benzamin"
}
索引数组字段
在数组中创建索引，需要对数组中的每个字段依次建立索引。
使用以下命令创建数组索引：
>db.users.ensureIndex({"tags":1})
检索集合的 tags 字段：
>db.users.find({tags:"cricket"})
索引子文档字段
假设需要通过city、state、pincode字段来检索文档，由于这些字段是子文档的字段，所以需要对子文档建立索引。
为子文档的三个字段创建索引，命令如下：
>db.users.ensureIndex({"address.city":1,"address.state":1,"address.pincode":1})
可以使用子文档的字段来检索数据：
>db.users.find({"address.city":"Los Angeles"})
查询表达不一定遵循指定的索引的顺序，mongodb 会自动优化。
索引限制
额外开销
每个索引占据一定的存储空间，在进行插入，更新和删除操作时也需要对索引进行操作。所以，如果很少对集合进行读取操作，建议不使用索引。
内存(RAM)使用
由于索引是存储在内存(RAM)中,应该确保该索引的大小不超过内存的限制。
如果索引的大小大于内存的限制，MongoDB会删除一些索引，这将导致性能下降。
查询限制
索引不能被以下的查询使用：
- 正则表达式及非操作符，如
$nin, $not, 等。 - 算术运算符，如 $mod, 等。
- $where 子句
索引键限制
从2.6版本开始，如果现有的索引字段的值超过索引键的限制，MongoDB中不会创建索引
插入文档超过索引键限制
如果文档的索引字段值超过了索引键的限制，MongoDB不会将任何文档转换成索引的集合。与mongorestore和mongoimport工具类似。
最大范围
- 集合中索引不能超过64个
- 索引名的长度不能超过128个字符
- 一个复合索引最多可以有31个字段
ObjectId
ObjectId 是一个12字节 BSON 类型数据，有以下格式：
- 前4个字节表示时间戳
- 接下来的3个字节是机器标识码
- 紧接的两个字节由进程id组成（PID）
- 最后三个字节是随机数。
创建新的ObjectId
newObjectId = ObjectId()
创建文档的时间戳
由于 ObjectId 中存储了 4 个字节的时间戳，所以可以通过 getTimestamp 函数来获取文档的创建时间:
ObjectId("5349b4ddd2781d08c09890f4").getTimestamp()
ObjectId 转换为字符串
new ObjectId().str
Map Reduce
Map-Reduce是一种计算模型，简单的说就是将大批量的工作（数据）分解（MAP）执行，然后再将结果合并成最终结果（REDUCE）。
MapReduce 命令
db.collection.mapReduce(
function() {emit(key,value);}, //map 函数
function(key,values) {return reduceFunction}, //reduce 函数
{
out: collection,
query: document,
sort: document,
limit: number
}
)
Map 函数调用 emit(key, value), 遍历 collection 中所有的记录, 将 key 与 value 传递给 Reduce 函数进行处理。
Map 函数必须调用 emit(key, value) 返回键值对。
参数说明:
- map ：映射函数 (生成键值对序列,作为 reduce 函数参数)。
- reduce 统计函数，reduce函数的任务就是将key-values变成key-value，也就是把values数组变成一个单一的值value。。
- out 统计结果存放集合 (不指定则使用临时集合,在客户端断开后自动删除)。
- query 一个筛选条件，只有满足条件的文档才会调用map函数。（query。limit，sort可以随意组合）
- sort 和limit结合的sort排序参数（也是在发往map函数前给文档排序），可以优化分组机制
- limit 发往map函数的文档数量的上限（要是没有limit，单独使用sort的用处不大）
以下实例在集合 orders 中查找 status:”A“ 的数据，并根据 cust_id 来分组，并计算 amount 的总和。
返回结果具体参数说明：
- result：储存结果的collection的名字,这是个临时集合，MapReduce的连接关闭后自动就被删除了。
- timeMillis：执行花费的时间，毫秒为单位
- input：满足条件被发送到map函数的文档个数
- emit：在map函数中emit被调用的次数，也就是所有集合中的数据总量
- output：结果集合中的文档个数（count对调试非常有帮助）
- ok：是否成功，成功为1
- err：如果失败，这里可以有失败原因，不过从经验上来看，原因比较模糊，作用不大
全文检索
全文检索对每一个词建立一个索引，指明该词在文章中出现的次数和位置，当用户查询时，检索程序就根据事先建立的索引进行查找，并将查找的结果反馈给用户的检索方式。
启用全文检索
MongoDB 在 2.6 版本以后是默认开启全文检索的，如果你使用之前的版本，你需要使用以下代码来启用全文检索:
>db.adminCommand({setParameter:true,textSearchEnabled:true})
或者使用命令：
mongod --setParameter textSearchEnabled=true
创建全文索引
以下 posts 集合的文档数据，包含了文章内容（post_text）及标签(tags)：
{
"post_text": "enjoy the mongodb articles on Runoob",
"tags": [
"mongodb",
"runoob"
]
}
对 post_text 字段建立全文索引
>db.posts.ensureIndex({post_text:"text"})
使用全文索引
搜索文章中的关键词 runoob：
>db.posts.find({$text:{$search:"runoob"}})
删除全文索引
删除已存在的全文索引，可以使用 find 命令查找索引名：
>db.posts.getIndexes()
通过以上命令获取索引名，本例的索引名为post_text_text，执行以下命令来删除索引：
>db.posts.dropIndex("post_text_text")
正则表达式
使用正则表达式
以下命令使用正则表达式查找包含 runoob 字符串的文章：
>db.posts.find({post_text:{$regex:"runoob"}})
以上查询也可以写为：
>db.posts.find({post_text:/runoob/})
不区分大小写的正则表达式
如果检索需要不区分大小写，我们可以设置 $options 为 $i。
以下命令将查找不区分大小写的字符串 runoob：
>db.posts.find({post_text:{$regex:"runoob",$options:"$i"}})
数组元素使用正则表达式
查找包含以 ru 开头的标签数据(ru 或 run 或 runoob)， 使用以下代码：
>db.posts.find({tags:{$regex:"ru"}})
优化正则表达式查询
- 如果你的文档中字段设置了索引，那么使用索引相比于正则表达式匹配查找所有的数据查询速度更快。
- 如果正则表达式是前缀表达式，所有匹配的数据将以指定的前缀字符串为开始。例如： 如果正则表达式为 ^tut ，查询语句将查找以 tut 为开头的字符串。
正则表达式中使用变量。一定要使用eval将组合的字符串进行转换，不能直接将字符串拼接后传入给表达式。否则没有报错信息，只是结果为空！实例如下：
var name=eval("/" + 变量值key +"/i");
操作符
* i 忽略大小写，{<field>{$regex/pattern/i}}，设置i选项后，模式中的字母会进行大小写不敏感匹配。
* m 多行匹配模式，{<field>{$regex/pattern/,$options:’m‘}，m选项会更改^和$元字符的默认行为，分别使用与行的开头和结尾匹配，而不是与输入字符串的开头和结尾匹配。
* x 忽略非转义的空白字符，{<field>:{$regex:/pattern/,$options:’m‘}，设置x选项后，正则表达式中的非转义的空白字符将被忽略，同时井号(#)被解释为注释的开头注，只能显式位于option选项中。
* s 单行匹配模式{<field>:{$regex:/pattern/,$options:’s‘}，设置s选项后，会改变模式中的点号(.)元字符的默认行为，它会匹配所有字符，包括换行符(\n)，只能显式位于option选项中。
* 使用$regex操作符时，需要注意下面几个问题:
* i，m，x，s可以组合使用，例如:{name:{$regex:/j*k/,$options:”si“}}
* 在设置索弓}的字段上进行正则匹配可以提高查询速度，而且当正则表达式使用的是前缀表达式时，查询速度会进一步提高，例如:{name:{$regex: /^joe/}
MongoDB 管理工具
- Rockmongo
- Navicat for MongoDB
- NoSQLBooster for MongoDB
GridFS
- GridFS 用于存储和恢复那些超过16M（BSON文件限制）的文件(如：图片、音频、视频等)。
- GridFS 也是文件存储的一种方式，但是它是存储在MonoDB的集合中。
- GridFS 可以更好的存储大于16M的文件。
- GridFS 会将大文件对象分割成多个小的chunk(文件片段),一般为256k/个,每个chunk将作为MongoDB的一个文档(document)被存储在chunks集合中。
- GridFS 用两个集合来存储一个文件：fs.files与fs.chunks。
- 每个文件的实际内容被存在chunks(二进制数据)中,和文件有关的meta数据(filename,content_type,还有用户自定义的属性)将会被存在files集合中。
以下是简单的 fs.files 集合文档：
{
"filename": "test.txt",
"chunkSize": NumberInt(261120),
"uploadDate": ISODate("2014-04-13T11:32:33.557Z"),
"md5": "7b762939321e146569b07f72c62cca4f",
"length": NumberInt(646)
}
以下是简单的 fs.chunks 集合文档：
{
"files_id": ObjectId("534a75d19f54bfec8a2fe44b"),
"n": NumberInt(0),
"data": "Mongo Binary Data"
}
GridFS 添加文件
mongofiles.exe -d gridfs put song.mp3
-d gridfs 指定存储文件的数据库名称，如果不存在该数据库，MongoDB会自动创建。Song.mp3 是音频文件名。
查看数据库中文件的文档：
>db.fs.files.find()
以上命令执行后返回以下文档数据：
{
_id: ObjectId('534a811bf8b4aa4d33fdf94d'),
filename: "song.mp3",
chunkSize: 261120,
uploadDate: new Date(1397391643474), md5: "e4f53379c909f7bed2e9d631e15c1c41",
length: 10401959
}
根据这个 _id 获取区块(chunk)的数据：
>db.fs.chunks.find({files_id:ObjectId('534a811bf8b4aa4d33fdf94d')})
以上实例中，查询返回了 40 个文档的数据，意味着mp3文件被存储在40个区块中。
固定集合
固定集合（Capped Collections）是性能出色且有着固定大小的集合，对于大小固定，可以想象其就像一个环形队列，当集合空间用完后，再插入的元素就会覆盖最初始的头部的元素！
创建固定集合
capped:true是固定集合标志，size是集合空间大小单位字节
>db.createCollection("cappedLogCollection",{capped:true,size:10000})
还可以指定文档个数,加上max:1000属性：
>db.createCollection("cappedLogCollection",{capped:true,size:10000,max:1000})
判断集合是否为固定集合:
>db.cappedLogCollection.isCapped()
如果需要将已存在的集合转换为固定集合可以使用以下命令：
db.runCommand({"convertToCapped":"posts",size:10000})
以上代码将已存在的 posts 集合转换为固定集合。
固定集合查询
固定集合文档按照插入顺序储存的,默认情况下查询就是按照插入顺序返回的,也可以使用KaTeX parse error: Expected '}', got 'EOF' at end of input: …n.find().sort({natural:-1})`
固定集合的功能特点
- 可以插入及更新,但更新不能超出collection的大小,否则更新失败,不允许删除,但是可以调用drop()删除集合中的所有行,但是drop后需要显式地重建集合。
- 在32位机子上一个cappped collection的最大值约为482.5M,64位上只受系统文件大小的限制。
固定集合属性及用法
属性
- 属性1:对固定集合进行插入速度极快
- 属性2:按照插入顺序的查询输出速度极快
- 属性3:能够在插入最新数据时,淘汰最早的数据
用法
- 用法1:储存日志信息
- 用法2:缓存一些少量的文档
自动增长
使用 counters 集合
考虑以下 products 文档。希望 _id 字段实现 从 1,2,3,4 到 n 的自动增长功能。
{
"_id":1,
"product_name": "Apple iPhone",
"category": "mobiles"
}
创建 counters 集合，序列字段值可以实现自动长：
>db.createCollection("counters")
向 counters 集合中插入以下文档，使用 productid 作为 key:
{
"_id":"productid",
"sequence_value": 0
}
sequence_value 字段是序列通过自动增长后的一个值。
使用以下命令插入 counters 集合的序列文档中：
>db.counters.insert({_id:"productid",sequence_value:0})
创建 Javascript 函数
创建函数 getNextSequenceValue 来作为序列名的输入， 指定的序列会自动增长 1 并返回最新序列值。在本文的实例中序列名为 productid 。
>function getNextSequenceValue(sequenceName){
var sequenceDocument = db.counters.findAndModify(
{
query:{_id: sequenceName },
update: {$inc:{sequence_value:1}},
"new":true
});
return sequenceDocument.sequence_value;
}
使用 Javascript 函数
使用 getNextSequenceValue 函数创建一个新的文档， 并设置文档 _id 自动为返回的序列值：
>db.products.insert({
"_id":getNextSequenceValue("productid"),
"product_name":"Apple iPhone",
"category":"mobiles"})
>db.products.insert({
"_id":getNextSequenceValue("productid"),
"product_name":"Samsung S3",
"category":"mobiles"})
使用 getNextSequenceValue 函数来设置 _id 字段。
使用以下命令读取文档：
>db.products.find()
以上命令将返回以下结果，发现 _id 字段是自增长的：
{ "_id" : 1, "product_name" : "Apple iPhone", "category" : "mobiles"}
{ "_id" : 2, "product_name" : "Samsung S3", "category" : "mobiles" }
4060
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
