https://www.cnblogs.com/zhoujie/p/mongo1.html

mongodb高級聚合查詢

　　在作業中會經常遇到一些mongodb的聚合操作，特此總結下，mongo存盤的可以是復雜型別，比如陣列、物件等mysql不善于處理的檔案型結構，并且聚合的操作也比mysql復雜很多，

注：本文基于 mongodb v3.6

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	一系列資料聚合操作或階段，詳見聚合管道運算子在版本2.6中更改：該方法仍然可以將流水線階段作為單獨的引數接受，而不是作為陣列中的元素;但是，如果不將管道指定為陣列，則不能指定options引數
options	document	可選， aggregate()傳遞給聚合命令的其他選項， 2.6版中的新增功能：僅當將管道指定為陣列時才可用，

注意：

使用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可以使用除了地理空間之外的所有常規查詢運算子，在實際應用中盡可能將$match放在管道的前面位置，這樣有兩個好處：一是可以快速將不需要的檔案過濾掉，以減少管道的作業量；二是如果再投射和分組之前執行$match，查詢可以使用索引，

限制：

不能在$ 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

轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/12759.html

標籤：NoSQL

上一篇：MongoDB聚合(aggregate)

下一篇：【Redis】入門

mongodb高級聚合查詢

mongodb高級聚合查詢

目錄

mongo與mysql聚合類比

Aggregate簡介

Aggregate語法

aggregate常用pipeline stage介紹

$count

釋義：

語法：

舉例：

$group

釋義：

語法：

accumulator運算子

舉例：

$match

釋義：

語法：

管道優化：

限制：

舉例：

$unwind

釋義：

語法：

舉例：

$project

釋義：

語法：

舉例：

$limit

$skip

$sort

$sortByCount