MongoDB学习笔记,基础+增删改查+索引+聚合...

一 基础了解

对应关系 -> https://docs.mongodb.com/manual/reference/sql-comparison/
database -> database
collection -> table
document -> row //无模式
field -> column
--------------------------------------------------------------------------------------
使用数据库
use 数据库名称

创建数据库并创建集合myNewCollection1插入数据
use myNewDB
db.myNewCollection1.insertOne( { x: 1 } )
--------------------------------------------------------------------------------------
创建集合并插入数据
db.myNewCollection22.insertOne( { xxx: 1 } )

固定大小集合 capped collection 先进先出
创建一个集合x1 是上限集合,大小200字节 最大2个document,先进先出
也可以不指定document大小db.createCollection("x1", { capped : true, size : 200} )
db.createCollection("x1", { capped : true, size : 200, max : 2 } )

检查是否为上限集合 false true
db.collection.isCapped() 

返回集合有多少document
db.collection.count() 

转换为上限集合
db.runCommand({"convertToCapped": "collection", size: 100000});

查看collection并升序转换成数组输出,降序 -1
printjson(db.collection.find().sort({$natural:1}).toArray())

collection methods ->
https://docs.mongodb.com/manual/reference/method/js-collection/
--------------------------------------------------------------------------------------
BSON Types

插入数据为undefined
db.collection.insert({x:undefined})
查找需要
db.getCollection('a001').find({x:undefined})//错误
db.getCollection('a001').find({x:{$type:6}})
db.getCollection('a001').find({x:{$type:"undefined"}})

详情:$type对应Number https://docs.mongodb.com/manual/reference/bson-types/

_id 5d89674154e8289fdac72ea5 十六进制

八位 5d896741 表示时间 十进制 1569285953 北京时间 2019/9/24 8:45:53
十位 54e8289fda 随机数 十进制 364672229338
六位 c72ea5 计数器从随机数开始 十进制 13053605

16 -> 10 进制 https://tool.lu/hexconvert/
时间戳 -> 北京时间 https://tool.chinaz.com/Tools/unixtime.aspx

二 基本查询操作

写在一起中间无换行表示同一个效果

// db.people.insertOne( {//插入并创建表
//     user_id: "abc123",
//     age: 55,
//     status: "A"
//  } )

// db.people.createIndex( { user_id: 1 } )//创建 增索引

// db.people.createIndex( { user_id: 1, age: -1 } )//创建 增索引 和 减索引

// db.people.drop()//删除表

// db.people.updateMany(//设置列 join_date 内容为当前时间,列没有就添加
//     { },
//     { $set: { join_date: new Date() } }
// )

// db.people.updateMany(//删除所有列 join_date
//     { },
//     { $unset: { "join_date": "" } }
// )

// db.people.insertOne(//插入一条数据
//    { user_id: "bcd001", age: 45, status: "A" }
// )

// db.people.find()//查询所有数据

// db.people.find(//只查询三个字段 _id user_id status
//     { },
//     { user_id: 1, status: 1 }
// )

// db.people.find(//只查询两个字段 user_id status
//     { },
//     { user_id: 1, status: 1, _id: 0 }
// )

// db.people.find(//查询状态不等于A
//     { status: { $ne: "A" } }
// )

// db.people.find(//查询status="A" AND age=50
//     { status: "A",
//       age: 50 }
// )

// db.people.find(//查询status="A" OR age=50
//     { $or: [ { status: "A" } , { age: 50 } ] }
// )

// db.people.find(// >25
//     { age: { $gt: 25 } }
// )
    
//     db.people.find(// <25
//    { age: { $lt: 25 } }
// )
   
//    db.people.find(// >25 <=50
//    { age: { $gt: 25, $lte: 50 } }
// )

// db.people.find( { user_id: /abc/ } )// LIKE '%abc%'
// db.people.find( { user_id: { $regex: /abc/ } } )

// db.people.find( { user_id: /^abc/ } )// LIKE 'abc%'
// db.people.find( { user_id: { $regex: /^abc/ } } )

// db.people.find( { status: "A" } ).sort( { user_id: 1 } )//ASC

// db.people.find( { status: "A" } ).sort( { user_id: -1 } )//DESC

// db.people.count()// count(*)
// db.people.find().count()

// db.people.count( { user_id: { $exists: true } } )// 含有user_id的所有count(*)
// db.people.find( { user_id: { $exists: true } } ).count()

// db.people.count( { age: { $gt: 500 } } )//age>500的count(*)
// db.people.find( { age: { $gt: 500 } } ).count()

// db.people.aggregate( [ { $group : { _id : "$status" } } ] )//安装status分组,查询别名_id 只查询status
// db.people.distinct( "status" )//返回一个数组 ["A","B","C","CCCC"]

// db.people.findOne()//查询第一条
// db.people.find().limit(1)

// db.people.find().limit(5).skip(10)//查询大于第 11 12 13 14 15条,如果没有14 15 就显示 11 12 13

// db.people.updateMany(//更新年龄大于5555的状态设置为CCCC
//    { age: { $gt: 5555 } },
//    { $set: { status: "CCCC" } }
// )

// db.people.updateMany(//更新状态为CCCC的设置
//    { status: "CCCC" } ,
//    { $inc: { age: 3 } }
// )

// db.people.deleteMany( { status: "D" } )//删除状态为D的所有数据

// db.people.deleteMany({})//清空表数据

三 查询

查询

比较查询操作符 -> https://docs.mongodb.com/manual/reference/operator/query-comparison/

$eq -> = -> { <field>: { $eq: <value> } }

$ne -> != -> {field: {$ne: value} }

$gt -> > -> { field: { $gt: value} }

$gte -> >= -> { field: { $gte: value} }

$lt -> < -> { field: { $lt: value} }

$lte -> <= -> { field: { $lte: value} }

有一个就可以
$in -> in -> { field: { $in: [<value1>, <value2>, ... <valueN> ] } }

都没有才可以
$nin -> not in -> { field: { $nin: [ <value1>, <value2> ... <valueN> ]} }
--------------------------------------------------------------------------------------
逻辑查询操作符 -> https://docs.mongodb.com/manual/reference/operator/query-logical/

第一个false 余下不执行
$and -> and -> { $and: [ { <expression1> }, { <expression2> } , ... , { <expressionN> } ] }

$or -> or -> { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] }

对or的结果取反
$nor -> not or -> { $nor: [ { <expression1> }, { <expression2> }, ...  { <expressionN> } ] }

对符合的结果取反
$not -> not -> { field: { $not: { <operator-expression> } } }
--------------------------------------------------------------------------------------
元素查询操作符 -> https://docs.mongodb.com/manual/reference/operator/query-element/

$exists -> exists -> { field: { $exists: true/false } }

$type -> { field: { $type: [ <BSON type1> , <BSON type2>, ... ] } }
// { field: { $type: "string" } }
// { field: { $type: ["string","int"] } }
--------------------------------------------------------------------------------------
评估查询操作符 -> https://docs.mongodb.com/manual/reference/operator/query-evaluation/

// 根据表达式来匹配数据
$expr -> { $expr: { <expression> } }

// 根据schema来匹配 required必须含有,properties属性,bsonType类型
$jsonSchema -> { $jsonSchema: <JSON Schema object> }

这里匹配 如果field=0,1,2,3,4,5 v1=2 v2=1 表示除2余1的数,所以是1 3 5
$mod -> { field: { $mod: [ v1, v2 ] } }

匹配正则表达式
{filed:{$regex:/a/}} -> 只要含有a,区分大小写
{filed:{$regex:/^a/}} -> 第一个字母是a,区分大小写
$regex -> 通常用 方式3
{ <field>: { $regex: /pattern/, $options: '<options>' } }//方式1
{ <field>: { $regex: 'pattern', $options: '<options>' } }//方式2
{ <field>: { $regex: /pattern/<options> } }//方式3

全文检索,不支持中文,根据索引进行匹配,
$text -> 例如 { $text: { $search: "coffee" } } 查找含有coffee的

非常强大 支持js
$where
例如
db.x.find({
    $where:function(){
        return this.item=="ijk123"&&this.qty==3 //this表示document(行)
    }
})
--------------------------------------------------------------------------------------
数组查询操作符 -> https://docs.mongodb.com/manual/reference/operator/query-array/

必须所有的值都要有,$in则表示只有一个就可以
$all -> { <field>: { $all: [ <value1> , <value2> ... ] } }

只要匹配一个满足就可以
$elemMatch -> { <field>: { $elemMatch: { <query1>, <query2>, ... } } }
例如:
{ results: { $elemMatch: { $gte: 80, $lt: 85 } } }
{ results: { $elemMatch: { product: "xyz", score: { $gte: 8 } } } }

根据数组大小匹配
$size -> 
匹配数组大小为2的,两个效果相同
{ field: { $size: 2 } }
{$where:function(){return this.field.length==2}}

四 更新

更新

db.collection.update({},{$set:{"a":1}})更新第一条
db.collection.updateMany({},{$set:{"a":1}})更新全部

自动更新操作符 -> https://docs.mongodb.com/manual/reference/operator/update-field/
$inc -> { $inc: { <field1>: <amount1>, <field2>: <amount2>, ... } }
{},{$inc:{"age":1,"c":-2,"h.g":2}}//age+1 c-2 h.g+2 字段不存在会创建0+数值

$mul -> { $mul: { <field1>: <number1>, ... } }
{},{$mul:{"age":5,"h":-1}}//age*5 h*(-1) 数值也可为小数,字段不存在会创建为0*数值

新值最小 就更新
$min -> { $min: { <field1>: <value1>, ... } }

新值最大 就更新
$max -> { $max: { <field1>: <value1>, ... } }

$rename -> {$rename: { <field1>: <newName1>, <field2>: <newName2>, ... } }
{},{$rename:{"age":"age1","my.doc":"c.h"}}//更新字段 age -> age1 my.doc -> c.h

$set -> { $set: { <field1>: <value1>, ... } }
//如果不存在_id:1 不会做任何反应,如果存在,则会字段重新赋值,不存在的字段会添加
{_id:1},{$set:{"a":1,"h.g":2}}

$unset -> { $unset: { <field1>: "", ... } }
{},{$unset:{"a":""}}//字段a后面设置"" 这里就删除了字段a,不论a是什么类型

$setOnInsert ->
db.collection.update(
   <query>,
   { $setOnInsert: { <field1>: <value1>, ... } },
   { upsert: true }
)

例如:
db.collection.update(//collection为空 会插入一个文档,并且设置一条 _id:1 c1:apple c2:100
  { _id: 1 },
  {
     $set: { c1: "apple" },
     $setOnInsert: { c2: 100 }
  },
  { upsert: true }
)

$currentDate -> { $currentDate: { <field1>: <typeSpecification1>, ... } }
也可以把 date 换成 timestamp 字符戳
{},{$currentDate:{mydate:{$type:"date"}}}

五 数组

数组

$ -> { "<array>.$" : value }
可以作为占位符 表示一个 //_id=1 grades=80的把 grade.$ 改为999 只能改一条,改第一个
   { _id: 1, grades: 80 },
   { $set: { "grades.$" : 999 } }
{ "_id" : 1, "grades" : [ 85, 80, 80 ] } -> { "_id" : 1, "grades" : [ 85, 999, 80 ] }   

$[] -> { <update operator>: { "<array>.$[]" : value } }
可以做占位符 表示全部
{_id:1},{$inc:{"sz.$[]":3}}
{_id:1,sz:[1,2,3]} -> {_id:1,sz:[4,5,6]}

$[diy] -> 这里的diy可以随便改 就是一个标识符
{},{$set:{"sz.$[x]":777}},{arrayFilters:[{"$[x]":{$eq:3}}]}
{"_id:1","sz":[3,5,3]}
{"_id:2","sz":[3,3,8]}

{"_id:1","sz":[777,5,777]},
{"_id:2","sz":[777,777,8]}

$addToSet -> { $addToSet: { <field1>: <value1>, ... } }
将元素添加数组
{_id:1},{$addToSet:{"sz":"3"}} ->{"sz":["1","2"]} ->{"sz":["1","2","3"]}
{_id:1},{$addToSet:{"sz":["4","5"]}} ->{"sz":["1","2"]} ->{"sz":["1","2",["4","5"]]}

$pop -> { $pop: { <field>: <-1 | 1>, ... } }
{_id:1},{$pop:{"sz":-1}}//移除数组第一个
{_id:1},{$pop:{"sz":1}}//移除数组最后一个

$pull -> { $pull: { <field1>: <value|condition>, <field2>: <value|condition>, ... } }
字段后面跟条件 
 { _id: 1 }, { $pull: { scores: {$in:[0,5]} } }//自定义删除所有 0和5
  { _id: 1 }, { $pull: { scores: {$gt:7} } }//删除大于7的

$pullAll -> { $pullAll: { <field1>: [ <value1>, <value2> ... ], ... } }
删除数组所有的 0 和 5
 { _id: 1 }, { $pullAll: { scores: [ 0, 5 ] } }
 
$push -> { $push: { <field1>: <value1>, ... } }
{_id:1},{$push:{"sz":3}} -> {"sz":[1,2]} -> {"sz":[1,2,3]}//单个添加
{_id:1},{$push:{"sz":[4,5]}} -> {"sz":[1,2]} -> {"sz":[1,2,[4,5]]}//整体添加单个数组
{_id:1},{$push:{"sz":{$each:[4,5]}}} -> [1,2] -> [1,2,4,5]//批量添加
{_id:1},{$push:{"sz":{$each:[],$sort:1}}} -> [2,1,3] -> [1,2,3]//数组排序 1升序 -1降序
{_id:1},{$push:{"sz":{$each:[8,2],$sort:1}}} -> [2,1,3] -> [1,2,,2,3,8]//添加+排序
{_id:1},{$push:{"sz":{$each:[5,6],$sort:1,$slice:3}}}
原数据 -> 添加 -> 排序(1升序 -1降序) -> 截取(3前三条 -3后三条)
[2,1,3] -> [2,1,3,5,6] ->[1,2,3,5,6] ->[1,2,3]

$each
{ $addToSet: { <field>: { $each: [ <value1>, <value2> ... ] } } }
{ $push: { <field>: { $each: [ <value1>, <value2> ... ] } } }

{_id:1},{$addToSet:{"sz":{$each:[4,5]}}}// [2,1] -> [2,1,4,5]
{_id:1},{$push:{"sz":{$each:[4,5]}}}// [2,1] -> [2,1,4,5]

$slice 截取 -> 配合$push $each一起使用
{_id:1},{$push:{"sz":{$each:[8,6],$slice:3}}}
[1,2] -> [1,2,8]// 3前三条 -3后三条 0清空数组

$sort 排序 -> 配合$push $each一起使用
{_id:1},{$push:{"sz":{$each:[8,6],$sort:1}}}
[1,2] -> [1,2,6,8]// 1升序 -1降序

$position 插入位置 -> 配合$push $each一起使用
{_id:1},{$push:{"sz":{$each:[9],$position:1}}}
[3,5,8] -> [3,1,5,8]
1表示在第一个元素后面追加 0表示在开头添加 大于元素个数表示在最后追加

六 增删改查

增删改查

insert
db.collection.insertOne({})//插入一条
db.collection.insertOne({})//插入第一条
db.collection.insertMany([{},{}])//插入多条
db.collection.insert({})//插入一条
db.collection.insert({},{})//插入第一条
db.collection.insert([{},{}])//插入多条

delete
db.collection.deleteOne({"a":1})//删除a为1的第一条
db.collection.deleteMany({"a":1})//删除a为1的全部
db.collection.deleteMany({})//清空collection
db.collection.remove()
{"a":1}//删除a为1的全部
{"a":1},{justOne:true}//删除a为1的第一条

update
db.collection.updateOne({"a":1},{$set:{"a":2}})//更新第一条
db.collection.updateOne({"a":1},{$set:{"a":2}})//更新全部
db.collection.replaceOne({"a":1},{"b":2,"c":3})//替换第一条的数据

find
db.collection.findOne({"a":1})//查询符合条件的第一条数据
db.collection.find({})//查询collection全部数据
db.collection.findOneAndDelete({"a":1})//查询正常返回第一条并且删除
db.collection.findOneAndReplace({"a":1},{"c":2,"d":3})//查询正常返回第一条并且替换
//查询正常返回第一条并更新,字段不存在就添加
db.collection.findOneAndUpdate({"d":"dd"},{$set:{"e":"ee"}})

bulk 支持以下方法,一个出错,不影响其他的
insertOne
updateOne
updateMany
replaceOne
deleteOne
deleteMany

try {
   db.characters.bulkWrite(
      [
         { insertOne :
            {
               "document" :
               {
                  "_id" : 4, "char" : "Dithras", "class" : "barbarian", "lvl" : 4
               }
            }
         },
         { insertOne :
            {
               "document" :
               {
                  "_id" : 5, "char" : "Taeln", "class" : "fighter", "lvl" : 3
               }
            }
         },
         { updateOne :
            {
               "filter" : { "char" : "Eldon" },
               "update" : { $set : { "status" : "Critical Injury" } }
            }
         },
         { deleteOne :
            { "filter" : { "char" : "Brisbane"} }
         },
         { replaceOne :
            {
               "filter" : { "char" : "Meldane" },
               "replacement" : { "char" : "Tanys", "class" : "oracle", "lvl" : 4 }
            }
         }
      ]
   );
}
catch (e) {
   print(e);
}

七 索引创建

索引创建

Single Index 单键索引
db.collection.createIndex({"a":1})//a非数组 1升序索引 -1降序索引

Compound Index 复合索引
db.collection.createIndex( { "a": 1, "b": 1 } )

Multikey Index 多键值索引
db.collection.createIndex({"a":1})//这里的a是一个数组
db.collection.createIndex({"a":1,"b":1})//a数组 b非数组 创建复合索引

Text Indexes 全文索引,不支持中文
db.collection.createIndex( { "a": "text" } )

Hashed Indexes 哈希索引
db.collection.createIndex( { "_id": "hashed" } )

Unique Indexes 唯一索引
插入数据不可以重复
db.collection.createIndex( { "a": 1 }, { unique: true } )

Partial Indexes 局部索引
db.users.createIndex(//年龄>=21才能给username加升序索引,唯一索引
   { username: 1 },
   { unique: true, partialFilterExpression: { age: { $gte: 21 } } }
)

Sparse Indexes 稀疏索引
db.collection.createIndex({"a":1},{sparse:true})//对a建立索引

TTL Indexes 过期索引*重要,可做定时过期
1,只支持单个索引,复合索引不支持
2,类型要为 BSON 日期 或 含有 BSON 日期的数组
3,expireAfterSeconds 单位秒,正的 或 0 ,如果为0 在指定日期时到期
4,如果是数组,最小的那个时间到期就会删除
5,不含有该索引字段 或 字段不是日期类型,不会过期
6,_id 不能设置 TTL索引
7,时间到期后不会立马删除,后台60s执行一次

只能设置一个字段,单位秒
db.collection.createIndex({"a":1},{expireAfterSeconds:65})

八 索引管理

索引管理

//插入自定义时间
db.test.insert({'time':ISODate("2012-11-02 07:58:51")})

查看
	表的全部索引
	db.collection.getIndexes()
	
	索引字段名
	db.collection.getIndexKeys()

	数据库全部索引
	db.getCollectionNames().forEach(function(collection) {
	   indexes = db[collection].getIndexes();
	   print("Indexes for " + collection + ":");
	   printjson(indexes);
	});

删除
	删除b升序索引 -1删除降序索引
	db.collection.dropIndex({"b":1})

	删除全部索引
	db.collection.dropIndexes()
	
修改
    删除再创建

九 GridFS 分布式文件系统

GridFS 分布式文件系统

1,多机器储存备份
2,可以突破一般文件的限制,可以大于16M
3,分段存储,不是整个存储

mongofiles -> https://docs.mongodb.com/manual/reference/program/mongofiles/

默认localhost:27017
--host

默认27017
--port

指定数据库
--db

前缀 默认fs
--prefix
....
...
...

十 聚合管道

聚合管道 Aggregation Pipeline Stages -> https://docs.mongodb.com/manual/reference/operator/aggregation-pipeline/

db.collection.aggregate([{},{},...,{}])//一个{}表示一个管道
1,$addFields
2,$bucket
3,$bucketAuto
4,$collStats
5,$count

			aggregate([//查询字段score>80的总数,假设有3条记录 返回{"passing_scores":3}
				{
				  $match: {
					score: {$gt: 80}
				  }
				},
				{
				  $count: "passing_scores"
				}
			]);

6,$facet
7,$geoNear
8,$graphLookup
9,$group

		{
		  $group:
			{
			  _id: null或者$字段
			  <field1>: { <accumulator1> : <expression1> },
			  ...
			}
		}

		$sum 相加
			对字段price*quantity的结果相加得到总价格
			totalSaleAmount: { $sum: { $multiply: [ "$price", "$quantity" ] } }
		$avg 平均值
			邱quantity字段平均值
			averageQuantity: { $avg: "$quantity" }
		$first 第一个值
		$last 最后一个值
		$min 最小值
		$max 最大值
		$push 对结果
			对author分组,每个作者的标题String放入books数组
			{ $group : { _id : "$author", books: { $push: "$title" } } }

									aggregate( [//不分组 计算document数量
									  {
										$group: {
										   _id: null,
										   count: { $sum: 1 }
										}
									  }
									] );

									{ "_id" : null, "count" : 8 }
									---
									aggregate( [ { $group : { _id : "$item" } } ] );//按照item字段分组

									{ "_id" : "abc" }
									{ "_id" : "jkl" }
									{ "_id" : "def" }
									{ "_id" : "xyz" }
									---
									aggregate(
									  [
										// First Stage
										{
										  $group :
											{
											  _id : "$item",
											  totalSaleAmount: { $sum: { $multiply: [ "$price", "$quantity" ] } }
											}
										 },
										 // Second Stage
										 {
										   $match: { "totalSaleAmount": { $gte: 100 } }
										 }
									   ]
									 )
									//先按照item分组,对字段price*quantity的结果相加得到总价格,如果总价格>=100就显示
									---
									$group : {
										   _id : null,
										   totalSaleAmount: { $sum: { $multiply: [ "$price", "$quantity" ] } },
										   averageQuantity: { $avg: "$quantity" },
										   count: { $sum: 1 }
										}
									计算所有行的总销售额,所有行的quantity平均值,所有行的数量

10,$indexStats
11,$limit

		aggregate(//取5条数据
			{ $limit : 5 }
		);

12,$listSessions
13,$lookup 表关联

			aggregate([
			   {
				 $lookup:
				   {
					 from: "表2",
					 localField: "表1字段",
					 foreignField: "表2字段",
					 as: "表1添加列名,类型数组,放匹配表2的document"
				   }
			  },
			  {$match:{"_id":1}}//对结果再进行匹配 _id:1
			]);
			// localField String -> foreignField String
			// localField String[] -> foreignField String

14,$match -> { $match: { <query> } }

			aggregate(
				[ { $match : { author : "dave" } } ]
			);

15,$merge
16,$out

			aggregate([//把匹配到的结果放入diy的表中,如果已存在则自动清空内容再插入
				{
				  $match: {score: {$gt: 80}}
				},
				{
				  $out: "diy"
				}
			]);

17,$planCacheStats
18,$project -> 要显示哪些字段

			只显示_id title author字段
			aggregate( [ { $project : { title : 1 , author : 1 } } ] )

			只显示title author字段
			aggregate( [ { $project : { _id: 0, title : 1 , author : 1 } } ] )

			不显示lastModified字段
			aggregate( [ { $project : { "lastModified": 0 } } ] )

			不显示author.first lastModified字段
			aggregate( [ { $project : { "author.first" : 0, "lastModified" : 0 } } ] )

			不显示author字段中的first lastModified字段
			aggregate( [ { $project: { "author": { "first": 0}, "lastModified" : 0 } } ] )

			显示title author.first author.last 
			并显示字段 author.middle,值不能为"" 或 不存在字段
			aggregate( [
			   {
				  $project: {
					 title: 1,
					 "author.first": 1,
					 "author.last" : 1,
					 "author.middle": {
						$cond: {
						   if: { $eq: [ "", "$author.middle" ] },
						   then: "$$REMOVE",
						   else: "$author.middle"
						}
					 }
				  }
			   }
			] );

			aggregate( [ { $project: { "stop.title": 1 } } ] )
			等同于
			aggregate( [ { $project: { stop: { title: 1 } } } ] )

			aggregate(
			   [
				  {
					 $project: {
						title: 1,
						isbn: {
						   prefix: { $substr: [ "$isbn", 0, 3 ] },//下标 0 1 2
						   group: { $substr: [ "$isbn", 3, 2 ] },//下标 3 4
						   publisher: { $substr: [ "$isbn", 5, 4 ] },//下标 5 6 7 8
						   title: { $substr: [ "$isbn", 9, 3 ] },//下标 9 10 11
						   checkDigit: { $substr: [ "$isbn", 12, 1] }//下标 12
						},
						lastName: "$author.last",//添加新字段
						copiesSold: "$copies"//添加新字段
					 }
				  }
			   ]
			)

			数组 例子 { "_id" : 1, "x" : 1, "y" : 1 }
			aggregate( [ { $project: { myArray: [ "$x", "$y" ] } } ] ) 
			->{ "_id" : 1, "myArray" : [ 1, 1 ] }

			原字段中无someField,显示null
			aggregate( [ { $project: { myArray: [ "$x", "$y", "$someField" ] } } ] )
			-> { "_id" : 1, "myArray" : [ 1, 1, null ] }

19,$redact
20,$replaceRoot
21,$replaceWith
22,$sample
23,$set
24,$skip -> { $skip: <positive integer> }

			aggregate(// 不显示前面5条记录
				{ $skip : 5 }
			);

25,$sort ->{ $sort: { <field1>: <sort order>, <field2>: <sort order> ... } }

			aggregate([// 1升序 -1降序
				 { $sort : { age : 1, posts: -1 } }
			])

26,$sortByCount
27,$unset
28,$unwind

十一 mapReduce

mapReduce 重量级聚合 -> mapReduce -> map -> reduce -> finalize -> out


流程图解 -> https://docs.mongodb.com/manual/core/map-reduce/
使用方法 -> https://docs.mongodb.com/manual/reference/command/mapReduce/
			db.runCommand({
							 mapReduce: <collection>,
							 map: <function>,
							 reduce: <function>,
							 finalize: <function>,
							 out: <output>,
							 query: <document>,
							 sort: <document>,
							 limit: <number>,
							 scope: <document>,
							 jsMode: <boolean>,
							 verbose: <boolean>,
							 bypassDocumentValidation: <boolean>,
							 collation: <document>,
							 writeConcern: <document>
						 });
			 
方法介绍 -> https://docs.mongodb.com/manual/reference/method/db.collection.mapReduce/

			db.collection.mapReduce(
									 <map>,
									 <reduce>,
									 {
									   out: <collection>,
									   query: <document>,
									   sort: <document>,
									   limit: <number>,
									   finalize: <function>,
									   scope: <document>,
									   jsMode: <boolean>,
									   verbose: <boolean>,
									   bypassDocumentValidation: <boolean>
									 }
								   )
								   
常用四项:
   1,map
		function(){
			emit(this.cust_id, this.price);
		}
	  发射出去 key-value , 这里 this就是当前的document
   2,reduce
	   function(key, values) {
		  return result;//result类型与map类型一致
	   } 
   3,query  
		{ age:{ $gte: 18 }}
   4,finalize
		在reduce后执行
        function(key, reducedValue) {
			return modifiedObject;
		}
					

例1:------------------------------------
db.a.insert([
    {_id:1,sku_id:1,stock:1},
    {_id:2,sku_id:3,stock:2},
    {_id:3,sku_id:2,stock:3},
    {_id:4,sku_id:1,stock:4},
    {_id:5,sku_id:2,stock:5},
])

var diy_map=function(){
       emit(this.sku_id,this.stock)
}

var diy_reduce=function(k,v){
       return Array.sum(v)
}
    
db.runCommand({
    mapReduce:"a",//对应的collection名称
    map:diy_map,
    reduce:diy_reduce,
    out:{inline:1}//在内存中执行
})

输出
---
/* 1 */
{
    "results" : [ 
        {
            "_id" : 1.0,
            "value" : 5.0
        }, 
        {
            "_id" : 2.0,
            "value" : 8.0
        }, 
        {
            "_id" : 3.0,
            "value" : 2.0
        }
    ],
    "timeMillis" : 23,
    "counts" : {
        "input" : 5,
        "emit" : 5,
        "reduce" : 2,
        "output" : 3
    },
    "ok" : 1.0
}
---

如果把 return Array.sum(v) 换成 return {"my_k":k,"my_v":v} 则输出
---
/* 1 */
{
    "results" : [ 
        {
            "_id" : 1.0,
            "value" : {
                "my_k" : 1.0,
                "my_v" : [ 
                    1.0, 
                    4.0
                ]
            }
        }, 
        {
            "_id" : 2.0,
            "value" : {
                "my_k" : 2.0,
                "my_v" : [ 
                    3.0, 
                    5.0
                ]
            }
        }, 
        {
            "_id" : 3.0,
            "value" : 2.0
        }
    ],
    "timeMillis" : 24,
    "counts" : {
        "input" : 5,
        "emit" : 5,
        "reduce" : 2,
        "output" : 3
    },
    "ok" : 1.0
}
---
如果想把结果输出放入一个collection 把 out:{inline:1} 缓存 out:"diy_document" 输出
out:{inline:1}输出内容的"result":[{.},{.},{.}]换成 "result":"diy_document"
---
/* 1 */
{
    "result" : "c",
    "timeMillis" : 40,
    "counts" : {
        "input" : 5,
        "emit" : 5,
        "reduce" : 2,
        "output" : 3
    },
    "ok" : 1.0
}
---
diy_document内容为 out:{inline:1}输出result字段[]里的内容
---
/* 1 */
{
    "_id" : 1.0,
    "value" : {
        "my_k" : 1.0,
        "my_v" : [ 
            1.0, 
            4.0
        ]
    }
}

/* 2 */
{
    "_id" : 2.0,
    "value" : {
        "my_k" : 2.0,
        "my_v" : [ 
            3.0, 
            5.0
        ]
    }
}

/* 3 */
{
    "_id" : 3.0,
    "value" : 2.0
}
---

整合finalize

var diy_map=function(){
       emit(this.sku_id,this.stock)
}

var diy_reduce=function(k,v){
       return {"my_k":k,"my_v":v};
}

var diy_finalize=function(k,v){
    v.diy_field="我是在diy_finalize添加的字段"
    return {"my_k2":k,"my_v2":v};
}
    
db.runCommand({
    mapReduce:"a",//对应的collection名称
    map:diy_map,
    reduce:diy_reduce,
    finalize:diy_finalize,
    out:{inline:1}//在内存中执行
})

输出
---
/* 1 */
{
    "results" : [ 
        {
            "_id" : 1.0,
            "value" : {
                "my_k2" : 1.0,
                "my_v2" : {
                    "my_k" : 1.0,
                    "my_v" : [ 
                        1.0, 
                        4.0
                    ],
                    "diy_field" : "我是在diy_finalize添加的字段"
                }
            }
        }, 
        {
            "_id" : 2.0,
            "value" : {
                "my_k2" : 2.0,
                "my_v2" : {
                    "my_k" : 2.0,
                    "my_v" : [ 
                        3.0, 
                        5.0
                    ],
                    "diy_field" : "我是在diy_finalize添加的字段"
                }
            }
        }, 
        {
            "_id" : 3.0,
            "value" : {
                "my_k2" : 3.0,
                "my_v2" : 2.0
            }
        }
    ],
    "timeMillis" : 33,
    "counts" : {
        "input" : 5,
        "emit" : 5,
        "reduce" : 2,
        "output" : 3
    },
    "ok" : 1.0
}
---