mongoDB 学习笔记纯干货（mongoose、增删改查、聚合、索引、等等）

时间 2019-11-06

标签 mongodb 学习笔记干货 mongoose 增删聚合索引等等栏目 MongoDB 繁體版

原文原文链接

最后更新时间：2017-07-13 11:10:49html

原始文章连接：http://www.lovebxm.com/2017/07/13/mongodb_primer/node

MongoDB - 简介web

官网：https://www.mongodb.com/sql

MongoDB 是一个基于分布式文件存储的数据库，由 C++ 语言编写，旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。mongodb

MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。shell

MongoDB - 安装及运行数据库

下载

07/05/2017 Current Stable Release (3.4.6)编程

https://www.mongodb.com/download-center#community数组

MongoDB 将数据目录存储在 db 目录下，需手动建立。浏览器

E:\MongoDB\data\db

运行 MongoDB 服务器

为了从命令提示符下运行MongoDB服务器，你必须从MongoDB\bin目录中执行mongod.exe文件，不要关闭服务。ctrl + c关闭。

mongod.exe --dbpath E:\MongoDB\data\db

MongoDB 后台管理

运行 mongo.exe

MongoDB Shell是MongoDB自带的交互式Javascript shell,用来对MongoDB进行操做和管理的交互式环境。

将 MongoDB 服务器做为 Windows 服务运行

添加系统环境 path E:\MongoDB\Server\3.4\bin

检测：cmd 中输入 mongod --help

新建文件：E:\MongoDB\logs\logs.log

将 MongoDB 服务器做为 Windows 服务随 Windows 启动而开启：

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 - 常见操做

查看当前数据库

db

查看全部数据库

没有数据的数据库不予显示

MongoDB 中默认的数据库为 test，若是你没有建立新的数据库，集合将存放在 test 数据库中。

show dbs

链接到指定的数据库

若是数据库不存在，则建立数据库，不然切换到指定数据库。

use db_name

查看服务器状态

db.serverStatus()

查看数据库统计信息

db.stats()

删除数据库

db.dropDatabase()

查看数据库中全部集合

show tables
或
show collections

清空集合

删除里面的文档，但集合还在

db.col_name.remove({})

删除集合

db.col_name.drop()

查看集合详细信息

MongoDB 的3.0后的版本分了三种模式 queryPlanner、executionStats、allPlansExecution

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则须要遍历列表，一个个插入。

db.col_name.insert(document)

db.col_name.save(document)

插入一个文档到 col 集合中：

db.col_1.insert({
    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
});

db.col_2.insert(document)

删除

remove() 函数是用来删除集合中的数据

在执行 remove() 函数前先执行 find() 命令来判断执行的条件是否正确，这是一个比较好的习惯。

db.col_name.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)

- query :（可选）删除的文档的条件。
- justOne : （可选）若是设为 true 或 1，则只删除一个文档。
- writeConcern :（可选）抛出异常的级别。

删除集合中全部文档

db.col.remove({})

移除 col_1 集合中 title 为 MongoDB save 的文档，只删除第一条找到的记录

db.col_1.remove({'title':'MongoDB save'}, 1)

更新

MongoDB 使用 update() 和 save() 方法来更新集合中的文档

update() 方法用于更新已存在的文档

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 以后的数据，而不是覆盖以前的数据

db.col_1.update({ 'title': 'MongoDB 教程' }, { $set: { 'title': 'MongoDB' } })

以上语句只会修改第一条发现的文档，若是要修改多条相同的文档，则须要设置 multi 参数为 true。

db.col_1.update({ 'title': 'MongoDB 教程' }, { $set: { 'title': 'MongoDB' } }, { multi: true })

save() 方法经过传入的文档来替换已有文档。语法格式以下：

db.col_name.save(
   <document>,
   {
     writeConcern: <document>
   }
)

如下实例中咱们替换了 col_1 的文档数据：

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() 方法，它只返回一个文档。

db.col_name.find(query, projection)

- query ：可选，使用查询操做符指定查询条件
- projection ：可选，使用投影操做符指定返回的键。查询时返回文档中全部键值， 只需省略该参数便可（默认省略）。

格式化输出：

db.col_name.find().pretty()

查看集合中文档的个数：

db.col_name.find().count()

跳过指定数量的数据：

db.col_name.find().skip()

读取指定记录的条数：

db.col_name.find().limit()

排序：

sort()方法能够经过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。

db.col_name.find().sort({key:1})

sort()方法能够经过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。

Where 语句

若是你想获取"col"集合中 "likes" 大于100，小于 200 的数据，你可使用如下命令：

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 的数据，你可使用如下命令：

db.col.find({"title" : {$type : 2}})

AND 条件

find() 方法能够传入多个键(key)，每一个键(key)以逗号隔开，语法格式以下：

db.col_name.find({key1:value1, key2:value2}).pretty()

// 相似于 SQL and 语句：
SELECT * FROM col_name WHERE key1='value1' AND key2=value2

OR 条件

db.col_name.find({ $or: [{ "by": "菜鸟教程" }, { "title": "MongoDB 教程" }] }).pretty()

// 相似于 SQL or 语句：
SELECT * FROM col_name WHERE key1=value1 OR key2=value2

AND 和 OR 联合使用

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 查看集合索引状况

db.col_name.getIndexes()

hint 强制使用索引

db.col_name.find({age:{$lt:30}}).hint({name:1, age:1}).explain()

删除索引(不会删除 _id 索引)

db.col_name.dropIndexes()

db.col_name.dropIndex({firstname: 1})

createIndex() 方法

MongoDB使用 createIndex() 方法来建立索引

key 为你要建立的索引字段，1为按升序建立索引，-1为按降序建立索引。

也能够设置使用多个字段建立索引（关系型数据库中称做复合索引）

db.col_name.createIndex({key:1})

createIndex() 接收可选参数，可选参数列表以下：

_id 索引

对于每一个插入的数据，都会自动生成一条惟一的 _id 字段，_id 索引是绝大多数集合默认创建的索引

> 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 命名空间，由数据库名称.集合名称组成

单键索引

最普通的索引，不会自动建立

// 对 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中插入数组类型的多键数据，索引是自动创建的，无需刻意指定

> 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 ] }

复合索引

同时对多个字段建立索引

> 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 分钟左右）

> 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 函数一块儿使用效果更好

db.col_7.find({ $text: { $search: "aa bb" } }, { score: { $meta: "textScore" } }).sort({ score: { $meta: "textScore" } })

注意：

每一个集合只能建立一个全文索引
MongoDB 从 2.4 版本开始支持全文检索，从 3.2 版本开始支持中文
（好像）只能对整个单词查询，不能对单词的截取部分查询
关键词之间的空格表示或
关键词以前的 - 表示非
关键词加引号表示与 （需用 \ 转义）

> 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() 方法

db.col_name.aggregate(AGGREGATE_OPERATION)

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

实例

计算每一个做者所写的文章数

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

集合中的数据以下：

{
        "_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()计算结果以下：

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

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管道操做符进行处理。

db.articles.aggregate([
    { $match: { score: { $gt: 70, $lte: 90 } } },
    { $group: { _id: null, count: { $sum: 1 } } }
]);

 // 返回
{ "_id" : null, "count" : 1 }

$skip 实例

通过 $skip 管道操做符处理后，前2个文档被"过滤"掉。

db.col_1.aggregate({ $skip: 2 });

做者：连接：http://www.imooc.com/article/19162?block_id=tuijian_wz 来源：慕课网本文原创发布于慕课网，转载请注明出处，谢谢合做