https://www.cnblogs.com/zhoujie/p/mongo1.html
mongodb高級聚合查詢
在工作中會經常遇到一些mongodb的聚合操作，特此總結下。mongo存儲的可以是復雜類型，比如數組、對象等mysql不善於處理的文檔型結構，並且聚合的操作也比mysql復雜很多。
注：本文基於 mongodb v3.6
目錄
- mongo與mysql聚合類比
- aggregate簡介
- aggregate語法
- aggregate常用pipeline stage介紹(本文核心)
- node操作mongo聚合查詢（本文核心）
mongo與mysql聚合類比
為了便於理解，先將常見的mongo的聚合操作和mysql的查詢做下類比：
| SQL 操作/函數 | mongodb聚合操作 |
| where | $match |
| group by | $group |
| having | $match |
| select | $project |
| order by | $sort |
| limit | $limit |
| sum() | $sum |
| count() | $sum |
| join | $lookup （v3.2 新增） |
下面舉了一些常用的mongo聚合例子和mysql對比，假設有一條如下的數據庫記錄（表名：orders）作為例子：
{
cust_id: "abc123",
ord_date: ISODate("2012-11-02T17:04:11.102Z"),
status: 'A',
price: 50,
items: [ { sku: "xxx", qty: 25, price: 1 },
{ sku: "yyy", qty: 25, price: 1 } ]
}
1. 統計orders表所有記錄
db.orders.aggregate( [
{
$group: {
_id: null,
count: { $sum: 1 }
}
}
] )
類似mysql:
SELECT COUNT(*) AS count FROM orders
2.對orders表計算所有price求和
db.orders.aggregate( [
{
$group: {
_id: null,
total: { $sum: "$price" }
}
}
] )
類似mysql;
SELECT SUM(price) AS total FROM orders
3.對每一個唯一的cust_id, 計算price總和
db.orders.aggregate( [
{
$group: {
_id: "$cust_id",
total: { $sum: "$price" }
}
}
] )
類似mysql:
SELECT cust_id,
SUM(price) AS total
FROM orders
GROUP BY cust_id
4.對每一個唯一對cust_id和ord_date分組，計算price總和，不包括日期的時間部分
db.orders.aggregate( [
{
$group: {
_id: {
cust_id: "$cust_id",
ord_date: {
month: { $month: "$ord_date" },
day: { $dayOfMonth: "$ord_date" },
year: { $year: "$ord_date"}
}
},
total: { $sum: "$price" }
}
}
] )
類似mysql：
SELECT cust_id,
ord_date,
SUM(price) AS total
FROM orders
GROUP BY cust_id,
ord_date
5.對於有多個記錄的cust_id，返回cust_id和對應的數量
db.orders.aggregate( [
{
$group: {
_id: "$cust_id",
count: { $sum: 1 }
}
},
{ $match: { count: { $gt: 1 } } }
] )
類似mysql:
SELECT cust_id,
count(*)
FROM orders
GROUP BY cust_id
HAVING count(*) > 1
6.對每個唯一的cust_id和ord_date分組，計算價格總和，並只返回price總和大於250的記錄，且排除日期的時間部分
db.orders.aggregate( [
{
$group: {
_id: {
cust_id: "$cust_id",
ord_date: {
month: { $month: "$ord_date" },
day: { $dayOfMonth: "$ord_date" },
year: { $year: "$ord_date"}
}
},
total: { $sum: "$price" }
}
},
{ $match: { total: { $gt: 250 } } }
] )
類似mysql:
SELECT cust_id,
ord_date,
SUM(price) AS total
FROM orders
GROUP BY cust_id,
ord_date
HAVING total > 250
7.對每個唯一的cust_id且status=A，計算price總和
db.orders.aggregate( [
{ $match: { status: 'A' } },
{
$group: {
_id: "$cust_id",
total: { $sum: "$price" }
}
}
] )
類似mysql:
SELECT cust_id,
SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id
8.對每個唯一的cust_id且status=A，計算price總和並且只返回price總和大於250的記錄
db.orders.aggregate( [
{ $match: { status: 'A' } },
{
$group: {
_id: "$cust_id",
total: { $sum: "$price" }
}
},
{ $match: { total: { $gt: 250 } } }
] )
類似mysql:
SELECT cust_id,
SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id
HAVING total > 250
9.對於每個唯一的cust_id，將與orders相關聯的相應訂單項order_lineitem的qty字段進行總計
db.orders.aggregate( [
{ $unwind: "$items" },
{
$group: {
_id: "$cust_id",
qty: { $sum: "$items.qty" }
}
}
] )
類似mysql:
SELECT cust_id,
SUM(li.qty) as qty
FROM orders o,
order_lineitem li
WHERE li.order_id = o.id
GROUP BY cust_id
10.統計不同cust_id和ord_date分組的數量，排除日期的時間部分
db.orders.aggregate( [
{
$group: {
_id: {
cust_id: "$cust_id",
ord_date: {
month: { $month: "$ord_date" },
day: { $dayOfMonth: "$ord_date" },
year: { $year: "$ord_date"}
}
}
}
},
{
$group: {
_id: null,
count: { $sum: 1 }
}
}
] )
類似mysql:
SELECT COUNT(*)
FROM (SELECT cust_id, ord_date
FROM orders
GROUP BY cust_id, ord_date)
as DerivedTable
Aggregate簡介
db.collection.aggregate()是基於數據處理的聚合管道，每個文檔通過一個由多個階段（stage）組成的管道，可以對每個階段的管道進行分組、過濾等功能，然后經過一系列的處理，輸出相應的結果。
通過這張圖，可以了解Aggregate處理的過程。
1、db.collection.aggregate() 可以用多個構件創建一個管道，對於一連串的文檔進行處理。這些構件包括：篩選操作的match、映射操作的project、分組操作的group、排序操作的sort、限制操作的limit、和跳過操作的skip。
2、db.collection.aggregate()使用了MongoDB內置的原生操作，聚合效率非常高,支持類似於SQL Group By操作的功能，而不再需要用戶編寫自定義的JavaScript例程。
3、 每個階段管道限制為100MB的內存。如果一個節點管道超過這個極限,MongoDB將產生一個錯誤。為了能夠在處理大型數據集,可以設置allowDiskUse為true來在聚合管道節點把數據寫入臨時文件。這樣就可以解決100MB的內存的限制。
4、db.collection.aggregate()可以作用在分片集合，但結果不能輸在分片集合，MapReduce可以 作用在分片集合，結果也可以輸在分片集合。
5、db.collection.aggregate()方法可以返回一個指針（cursor），數據放在內存中，直接操作。跟Mongo shell 一樣指針操作。
6、db.collection.aggregate()輸出的結果只能保存在一個文檔中，BSON Document大小限制為16M。可以通過返回指針解決，版本2.6中后面：DB.collect.aggregate()方法返回一個指針，可以返回任何結果集的大小。
Aggregate語法
基本格式：
db.collection.aggregate(pipeline, options)
參數說明：
| 參數 | 類型 | 描述 |
| pipeline | array | 一系列數據聚合操作或階段。詳見聚合管道操作符 |
| options | document | 可選。 aggregate()傳遞給聚合命令的其他選項。 |
注意：
使用db.collection.aggregate()直接查詢會提示錯誤，但是傳一個空數組如db.collection.aggregate([])則不會報錯，且會和find一樣返回所有文檔。
pipeline有很多stage，但這里我只記錄我經常用到的幾個，如果后續用到再補充。stage詳見官網。
接下來介紹這幾個常用的stage:
$count , $group, $match, $project, $unwind, $limit, $skip, $sort, $sortByCount, $lookup, $out, $addFields
aggregate常用pipeline stage介紹
$count
釋義：
返回包含輸入到stage的文檔的計數，理解為返回與表或視圖的find()查詢匹配的文檔的計數。
db.collection.count()方法不執行find()操作，而是計數並返回與查詢匹配的結果數。
語法：
{ $count: <string> }
$count階段相當於下面$group+$project的序列：
db.collection.aggregate( [
{ $group: { _id: null, myCount: { $sum: 1 } } }, #這里myCount自定義，相當於mysql的select count(*) as myCount
{ $project: { _id: 0 } } # 返回不顯示_id字段
] )
舉例：
示例數據：
{ "_id" : 1, "subject" : "History", "score" : 88 }
{ "_id" : 2, "subject" : "History", "score" : 92 }
{ "_id" : 3, "subject" : "History", "score" : 97 }
{ "_id" : 4, "subject" : "History", "score" : 71 }
{ "_id" : 5, "subject" : "History", "score" : 79 }
{ "_id" : 6, "subject" : "History", "score" : 83 }
執行：
1）$match 階段排除score小於等於80的文檔，將大於80的文檔傳到下個階段
2）$count階段返回聚合管道中剩余文檔的計數，並將該值分配給名為passing_scores的字段。
執行結果：
$group
釋義：
按指定的表達式對文檔進行分組，並將每個不同分組的文檔輸出到下一個階段。輸出文檔包含一個_id字段，該字段按鍵包含不同的組。
輸出文檔還可以包含計算字段，該字段保存由$group的_id字段分組的一些accumulator表達式的值。 $group不會輸出具體的文檔而只是統計信息。
語法：
{ $group: { _id: <expression>, <field1>: { <accumulator1> : <expression1> }, ... } }
- _id字段是必填的;但是，可以指定_id值為null來為整個輸入文檔計算累計值。
- 剩余的計算字段是可選的，並使用<accumulator>運算符進行計算。
- _id和<accumulator>表達式可以接受任何有效的表達式。
accumulator操作符
| 名稱 | 描述 | 類比sql |
| $avg | 計算均值 | avg |
| $first | 返回每組第一個文檔，如果有排序，按照排序，如果沒有按照默認的存儲的順序的第一個文檔。 | limit 0,1 |
| $last | 返回每組最后一個文檔，如果有排序，按照排序，如果沒有按照默認的存儲的順序的最后個文檔。 | - |
| $max | 根據分組，獲取集合中所有文檔對應值得最大值。 | max |
| $min | 根據分組，獲取集合中所有文檔對應值得最小值。 | min |
| $push | 將指定的表達式的值添加到一個數組中。 | - |
| $addToSet | 將表達式的值添加到一個集合中（無重復值，無序）。 | - |
| $sum | 計算總和 | sum |
| $stdDevPop | 返回輸入值的總體標准偏差（population standard deviation） | - |
| $stdDevSamp | 返回輸入值的樣本標准偏差（the sample standard deviation） | - |
$group階段的內存限制為100M。默認情況下，如果stage超過此限制，$group將產生錯誤。但是，要允許處理大型數據集，請將allowDiskUse選項設置為true以啟用$group操作以寫入臨時文件。
友情備注：
- "$addToSet":expr，如果當前數組中不包含expr，那就將它添加到數組中。
- "$push":expr，不管expr是什么只，都將它添加到數組中。返回包含所有值的數組。
在版本2.6中進行了更改：對於$group階段，MongoDB引入了100M內存的限制以及allowDiskUse選項來處理大數據集的操作。
舉例：
示例數據：
{ "_id" : 1, "item" : "abc", "price" : 10, "quantity" : 2, "date" : ISODate("2014-03-01T08:00:00Z") }
{ "_id" : 2, "item" : "jkl", "price" : 20, "quantity" : 1, "date" : ISODate("2014-03-01T09:00:00Z") }
{ "_id" : 3, "item" : "xyz", "price" : 5, "quantity" : 10, "date" : ISODate("2014-03-15T09:00:00Z") }
{ "_id" : 4, "item" : "xyz", "price" : 5, "quantity" : 20, "date" : ISODate("2014-04-04T11:21:39.736Z") }
{ "_id" : 5, "item" : "abc", "price" : 10, "quantity" : 10, "date" : ISODate("2014-04-04T21:23:13.331Z") }
1. 以下匯總操作使用$group階段按月份，日期和年份對文檔進行分組，並計算total price和average quantity，並計算每個組的文檔數量：
返回：
/* 1 */
{
"_id" : {
"month" : 4,
"day" : 4,
"year" : 2014
},
"totalPrice" : 200,
"averageQuantity" : 15.0,
"count" : 2.0
}
/* 2 */
{
"_id" : {
"month" : 3,
"day" : 15,
"year" : 2014
},
"totalPrice" : 50,
"averageQuantity" : 10.0,
"count" : 1.0
}
/* 3 */
{
"_id" : {
"month" : 3,
"day" : 1,
"year" : 2014
},
"totalPrice" : 40,
"averageQuantity" : 1.5,
"count" : 2.0
}
2. group null , 以下聚合操作將指定組_id為null，計算集合中所有文檔的總價格和平均數量以及計數：
3. 查詢distinct values
以下匯總操作使用$group階段按item對文檔進行分組以檢索不同的項目值：
4. 數據轉換
1）將集合中的數據按price分組轉換成item數組
返回的數據id值是group中指定的字段，items可以自定義，是分組后的列表
2）下面聚合操作實用系統變量$$ROOT按item對文檔進行分組，生成的文檔不得超過BSON文檔大小限制。
返回：
/* 1 */
{
"_id" : "xyz",
"books" : [
{
"_id" : 3,
"item" : "xyz",
"price" : 5,
"quantity" : 10,
"date" : ISODate("2014-03-15T09:00:00.000Z")
},
{
"_id" : 4,
"item" : "xyz",
"price" : 5,
"quantity" : 20,
"date" : ISODate("2014-04-04T11:21:39.736Z")
}
]
}
/* 2 */
{
"_id" : "jkl",
"books" : [
{
"_id" : 2,
"item" : "jkl",
"price" : 20,
"quantity" : 1,
"date" : ISODate("2014-03-01T09:00:00.000Z")
}
]
}
/* 3 */
{
"_id" : "abc",
"books" : [
{
"_id" : 1,
"item" : "abc",
"price" : 10,
"quantity" : 2,
"date" : ISODate("2014-03-01T08:00:00.000Z")
},
{
"_id" : 5,
"item" : "abc",
"price" : 10,
"quantity" : 10,
"date" : ISODate("2014-04-04T21:23:13.331Z")
}
]
}
$match
釋義：
過濾文檔，僅將符合指定條件的文檔傳遞到下一個管道階段。
$match接受一個指定查詢條件的文檔。查詢語法與讀操作查詢語法相同。
語法：
{ $match: { <query> } }
管道優化：
限制：
- 不能在$ match查詢中使用$作為聚合管道的一部分。
- 要在$match階段使用$text，$match階段必須是管道的第一階段。
- 視圖不支持文本搜索。
舉例：
示例數據：
{ "_id" : ObjectId("512bc95fe835e68f199c8686"), "author" : "dave", "score" : 80, "views" : 100 }
{ "_id" : ObjectId("512bc962e835e68f199c8687"), "author" : "dave", "score" : 85, "views" : 521 }
{ "_id" : ObjectId("55f5a192d4bede9ac365b257"), "author" : "ahn", "score" : 60, "views" : 1000 }
{ "_id" : ObjectId("55f5a192d4bede9ac365b258"), "author" : "li", "score" : 55, "views" : 5000 }
{ "_id" : ObjectId("55f5a1d3d4bede9ac365b259"), "author" : "annT", "score" : 60, "views" : 50 }
{ "_id" : ObjectId("55f5a1d3d4bede9ac365b25a"), "author" : "li", "score" : 94, "views" : 999 }
{ "_id" : ObjectId("55f5a1d3d4bede9ac365b25b"), "author" : "ty", "score" : 95, "views" : 1000 }
1.使用 $match做簡單的匹配查詢
返回：
/* 1 */
{
"_id" : ObjectId("512bc95fe835e68f199c8686"),
"author" : "dave",
"score" : 80,
"views" : 100
}
/* 2 */
{
"_id" : ObjectId("512bc962e835e68f199c8687"),
"author" : "dave",
"score" : 85,
"views" : 521
}
2. 使用$match管道選擇要處理的文檔，然后將結果輸出到$group管道以計算文檔的計數：
返回：
/* 1 */
{
"_id" : null,
"count" : 5.0
}
$unwind
釋義：
從輸入文檔解構數組字段以輸出每個元素的文檔。簡單說就是 可以將數組拆分為單獨的文檔。
語法：
{ $unwind: <field path> }
要指定字段路徑，在字段名稱前加上$符並用引號括起來。
v3.2+支持如下語法：
{
$unwind:
{
path: <field path>,
includeArrayIndex: <string>, #可選,一個新字段的名稱用於存放元素的數組索引。該名稱不能以$開頭。
preserveNullAndEmptyArrays: <boolean> #可選，default :false，若為true,如果路徑為空，缺少或為空數組，則$unwind輸出文檔
}
}
如果為輸入文檔中不存在的字段指定路徑，或者該字段為空數組，則$unwind默認會忽略輸入文檔，並且不會輸出該輸入文檔的文檔。
版本3.2中的新功能：要輸出數組字段丟失的文檔，null或空數組，請使用選項preserveNullAndEmptyArrays。
舉例：
1. 示例數據1：
{ "_id" : 1, "item" : "ABC1", sizes: [ "S", "M", "L"] }
以下聚合使用$unwind為sizes數組中的每個元素輸出一個文檔：
db.getCollection('test').aggregate(
[ { $unwind : "$sizes" } ]
)
返回：
{ "_id" : 1, "item" : "ABC1", "sizes" : "S" }
{ "_id" : 1, "item" : "ABC1", "sizes" : "M" }
{ "_id" : 1, "item" : "ABC1", "sizes" : "L" }
每個文檔與輸入文檔相同，除了sizes字段的值是原始sizes數組的值。
2. 再如下示例數據：
{ "_id" : 1, "item" : "ABC", "sizes": [ "S", "M", "L"] }
{ "_id" : 2, "item" : "EFG", "sizes" : [ ] }
{ "_id" : 3, "item" : "IJK", "sizes": "M" }
{ "_id" : 4, "item" : "LMN" }
{ "_id" : 5, "item" : "XYZ", "sizes" : null }
1）以下$unwind操作使用includeArrayIndex選項來輸出數組元素的數組索引。
db.getCollection('test').aggregate( [ { $unwind: { path: "$sizes", includeArrayIndex: "arrayIndex" } } ] )
返回：
{ "_id" : 1, "item" : "ABC", "sizes" : "S", "arrayIndex" : NumberLong(0) }
{ "_id" : 1, "item" : "ABC", "sizes" : "M", "arrayIndex" : NumberLong(1) }
{ "_id" : 1, "item" : "ABC", "sizes" : "L", "arrayIndex" : NumberLong(2) }
{ "_id" : 3, "item" : "IJK", "sizes" : "M", "arrayIndex" : null }
2）以下$unwind操作使用preserveNullAndEmptyArrays選項在輸出中包含缺少size字段，null或空數組的文檔。
db.inventory.aggregate( [
{ $unwind: { path: "$sizes", preserveNullAndEmptyArrays: true } }
] )
返回：
{ "_id" : 1, "item" : "ABC", "sizes" : "S" }
{ "_id" : 1, "item" : "ABC", "sizes" : "M" }
{ "_id" : 1, "item" : "ABC", "sizes" : "L" }
{ "_id" : 2, "item" : "EFG" }
{ "_id" : 3, "item" : "IJK", "sizes" : "M" }
{ "_id" : 4, "item" : "LMN" }
{ "_id" : 5, "item" : "XYZ", "sizes" : null }
$project
釋義：
$project可以從文檔中選擇想要的字段，和不想要的字段（指定的字段可以是來自輸入文檔或新計算字段的現有字段
），也可以通過管道表達式進行一些復雜的操作，例如數學操作，日期操作，字符串操作，邏輯操作。
語法：
{ $project: { <specification(s)> } }
$project 管道符的作用是選擇字段（指定字段，添加字段，不顯示字段,_id：0，排除字段等），重命名字段，派生字段。
specifications有以下形式：
<field>: <1 or true> 是否包含該字段，field:1/0，表示選擇/不選擇 field
_id: <0 or false> 是否指定_id字段
<field>: <expression> 添加新字段或重置現有字段的值。 在版本3.6中更改：MongoDB 3.6添加變量REMOVE。如果表達式的計算結果為$$REMOVE，則該字段將排除在輸出中。
<field>:<0 or false> v3.4新增功能，指定排除字段
- 默認情況下，_id字段包含在輸出文檔中。要在輸出文檔中包含輸入文檔中的任何其他字段，必須明確指定$project中的包含。 如果指定包含文檔中不存在的字段，$project將忽略該字段包含，並且不會將該字段添加到文檔中。
- 默認情況下，_id字段包含在輸出文檔中。要從輸出文檔中排除_id字段，必須明確指定$project中的_id字段為0。
- v3.4版新增功能-如果指定排除一個或多個字段，則所有其他字段將在輸出文檔中返回。 如果指定排除_id以外的字段，則不能使用任何其他$project規范表單：即，如果排除字段，則不能指定包含字段，重置現有字段的值或添加新字段。此限制不適用於使用REMOVE變量條件排除字段。
- v3.6版本中的新功能- 從MongoDB 3.6開始，可以在聚合表達式中使用變量REMOVE來有條件地禁止一個字段。
- 要添加新字段或重置現有字段的值，請指定字段名稱並將其值設置為某個表達式。
- 要將字段值直接設置為數字或布爾文本，而不是將字段設置為解析為文字的表達式，請使用$literal操作符。否則，$project會將數字或布爾文字視為包含或排除該字段的標志。
- 通過指定新字段並將其值設置為現有字段的字段路徑，可以有效地重命名字段。
- 從MongoDB 3.2開始，$project階段支持使用方括號[]直接創建新的數組字段。如果數組規范包含文檔中不存在的字段，則該操作會將空值替換為該字段的值。
- 在版本3.4中更改-如果$project 是一個空文檔，MongoDB 3.4和更高版本會產生一個錯誤。
- 投影或添加/重置嵌入文檔中的字段時，可以使用點符號。如：
"contact.address.country": <1 or 0 or expression>
或
contact: { address: { country: <1 or 0 or expression> } }
舉例：
示例數據：
{
"_id" : 1,
title: "abc123",
isbn: "0001122223334",
author: { last: "zzz", first: "aaa" },
copies: 5,
lastModified: "2016-07-28"
}
1. 以下$project階段的輸出文檔中只包含_id，title和author字段：
db.getCollection('test').aggregate( [ { $project : { title : 1 , author : 1 } } ] )
返回：
{ "_id" : 1, "title" : "abc123", "author" : { "last" : "zzz", "first" : "aaa" } }
2. _id字段默認包含在內。要從$ project階段的輸出文檔中排除_id字段，請在project文檔中將_id字段設置為0來指定排除_id字段。
db.getCollection('test').aggregate( [ { $project : { _id: 0, title : 1 , author : 1 } } ] )
返回：
{ "title" : "abc123", "author" : { "last" : "zzz", "first" : "aaa" } }
3.以下$ project階段從輸出中排除lastModified字段：
db.getCollection('test').aggregate( [ { $project : { "lastModified": 0 } } ] )
4.從嵌套文檔中排除字段， 在$ project階段從輸出中排除了author.first和lastModified字段：
db.test.aggregate( [ { $project : { "author.first" : 0, "lastModified" : 0 } } ] )
或者可以將排除規范嵌套在文檔中：
db.test.aggregate( [ { $project: { "author": { "first": 0}, "lastModified" : 0 } } ] )
返回：
{
"_id" : 1,
"title" : "abc123",
"isbn" : "0001122223334",
"author" : {
"last" : "zzz"
},
"copies" : 5,
}
3.6版本中的新功能。從MongoDB 3.6開始，可以在聚合表達式中使用變量REMOVE來有條件地禁止一個字段。
示例數據：
{
"_id" : 1,
title: "abc123",
isbn: "0001122223334",
author: { last: "zzz", first: "aaa" },
copies: 5,
lastModified: "2016-07-28"
}
{
"_id" : 2,
title: "Baked Goods",
isbn: "9999999999999",
author: { last: "xyz", first: "abc", middle: "" },
copies: 2,
lastModified: "2017-07-21"
}
{
"_id" : 3,
title: "Ice Cream Cakes",
isbn: "8888888888888",
author: { last: "xyz", first: "abc", middle: "mmm" },
copies: 5,
lastModified: "2017-07-22"
}
5. 下面的$project階段使用REMOVE變量來排除author.middle字段，前提是它等於""：
db.books.aggregate( [
{
$project: {
title: 1,
"author.first": 1,
"author.last" : 1,
"author.middle": {
$cond: {
if: { $eq: [ "", "$author.middle" ] },
then: "$$REMOVE",
else: "$author.middle"
}
}
}
}
] )
返回：
{ "_id" : 1, "title" : "abc123", "author" : { "last" : "zzz", "first" : "aaa" } }
{ "_id" : 2, "title" : "Baked Goods", "author" : { "last" : "xyz", "first" : "abc" } }
{ "_id" : 3, "title" : "Ice Cream Cakes", "author" : { "last" : "xyz", "first" : "abc", "middle" : "mmm" } }
包含來自嵌入文檔的指定字段（結果只返回包含嵌套文檔的字段，當然也包括_id）
示例文檔：
{ _id: 1, user: "1234", stop: { title: "book1", author: "xyz", page: 32 } }
{ _id: 2, user: "7890", stop: [ { title: "book2", author: "abc", page: 5 }, { title: "book3", author: "ijk", page: 100 } ] }
只返回stop字段中的title字段：
db.bookmarks.aggregate( [ { $project: { "stop.title": 1 } } ] )
或
db.bookmarks.aggregate( [ { $project: { stop: { title: 1 } } } ] )
返回：
{ "_id" : 1, "stop" : { "title" : "book1" } }
{ "_id" : 2, "stop" : [ { "title" : "book2" }, { "title" : "book3" } ] }
包含計算字段
示例數據：
{
"_id" : 1,
title: "abc123",
isbn: "0001122223334",
author: { last: "zzz", first: "aaa" },
copies: 5
}
返回字段新增了isbn, lastname和copiesold
db.books.aggregate(
[
{
$project: {
title: 1,
isbn: {
prefix: { $substr: [ "$isbn", 0, 3 ] },
group: { $substr: [ "$isbn", 3, 2 ] },
publisher: { $substr: [ "$isbn", 5, 4 ] },
title: { $substr: [ "$isbn", 9, 3 ] },
checkDigit: { $substr: [ "$isbn", 12, 1] }
},
lastName: "$author.last",
copiesSold: "$copies"
}
}
]
)
上面執行的返回結果：
{
"_id" : 1,
"title" : "abc123",
"isbn" : {
"prefix" : "000",
"group" : "11",
"publisher" : "2222",
"title" : "333",
"checkDigit" : "4"
},
"lastName" : "zzz",
"copiesSold" : 5
}
投影出新數組字段
示例數據：
{ "_id" : ObjectId("55ad167f320c6be244eb3b95"), "x" : 1, "y" : 1 }
下面的聚合操作將返回新的數組字段myArray:
db.collection.aggregate( [ { $project: { myArray: [ "$x", "$y" ] } } ] )
返回：
{ "_id" : ObjectId("55ad167f320c6be244eb3b95"), "myArray" : [ 1, 1 ] }
如果返回的數組包含了不存在的字段，則會返回null:
db.collection.aggregate( [ { $project: { myArray: [ "$x", "$y", "$someField" ] } } ] )
返回：
{ "_id" : ObjectId("55ad167f320c6be244eb3b95"), "myArray" : [ 1, 1, null ] }
$limit
限制傳遞到管道中下一階段的文檔數
語法：
{ $limit: <positive integer> }
示例：
db.article.aggregate(
{ $limit : 5 }
);
此操作僅返回管道傳遞給它的前5個文檔。 $limit對其傳遞的文檔內容沒有影響。
注意：
當$sort在管道中的$limit之前立即出現時，$sort操作只會在過程中維持前n個結果，其中n是指定的限制，而MongoDB只需要將n個項存儲在內存中。當allowDiskUse為true並且n個項目超過聚合內存限制時，此優化仍然適用。
$skip
跳過進入stage的指定數量的文檔，並將其余文檔傳遞到管道中的下一個階段
語法：
{ $skip: <positive integer> }
示例：
db.article.aggregate(
{ $skip : 5 }
);
此操作將跳過管道傳遞給它的前5個文檔。 $skip對沿着管道傳遞的文檔的內容沒有影響。
$sort
對所有輸入文檔進行排序，並按排序順序將它們返回到管道。
語法：
{ $sort: { <field1>: <sort order>, <field2>: <sort order> ... } }
$sort指定要排序的字段和相應的排序順序的文檔。 <sort order>可以具有以下值之一：
- 1指定升序。
- -1指定降序。
- {$meta：“textScore”}按照降序排列計算出的textScore元數據。
示例：
要對字段進行排序，請將排序順序設置為1或-1，以分別指定升序或降序排序，如下例所示：
db.users.aggregate(
[
{ $sort : { age : -1, posts: 1 } }
]
)
比較不同BSON類型的值時，MongoDB使用以下比較順序，從最低到最高：
1 MinKey (internal type) 2 Null 3 Numbers (ints, longs, doubles, decimals) 4 Symbol, String 5 Object 6 Array 7 BinData 8 ObjectId 9 Boolean 10 Date 11 Timestamp 12 Regular Expression 13 MaxKey (internal type)
$sortByCount
v3.4新增。根據指定表達式的值對傳入文檔分組，然后計算每個不同組中文檔的數量。每個輸出文檔都包含兩個字段：包含不同分組值的_id字段和包含屬於該分組或類別的文檔數的計數字段，文件按降序排列。
語法：
{ $sortByCount: <expression> }
reference:
https://www.jianshu.com/p/e60d5cfbeb35
https://www.cnblogs.com/ljhdo/p/5019837.html