// 1. 插入多條資料
db.inventory.insertMany([
   { item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] },
   { item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] },
   { item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] },
   { item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] },
   { item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }
]);

// 2.1 陣列元素完全匹配查詢（值、值的個數、順序，都要完全一致才返回）。 
// 這個語句就是查詢tags陣列下只且只有red/blank兩個值的元素，且順序要為red、blank。
db.inventory.find( { tags: ["red", "blank"] } )
// 結果可見下圖

// 2.2 陣列元素部分匹配查詢（只要陣列元素中的值，部分值匹配要查詢的條件，就可以返回，無關順序）， 要使用  $all 操作符
// 這個語句意思是說，查詢tags陣列中，只要元素值裡面有red和blank(注意，是多個條件同時存在)，就返回，無關順序。
db.inventory.find( { tags: { $all: ["red", "blank"] } } )
// 結果可見下圖

// 2.3 陣列元素單個值匹配和範圍查詢
// 比如查詢元素中包含某個值的檔案，或者元素中存在位於查詢範圍區間的值的檔案。 
// 2.3.1 這個是查詢元素中存在red值的檔案，注意，這裡不像上面的完全匹配或者部分匹配時使用中括號，而是直接把值帶進去。 
db.inventory.find( { tags: "red" } )

// 2.3.2 這個是查詢陣列元素中存在符合區間範圍的值的元素（類似部分匹配），一般會傳入$gt/$lt/$gte/$lte/$ne/$eq之類的匹配範圍操作符
// 這裡是查詢 dim_cm陣列中，存在大於25的值的元素。 
db.inventory.find( { dim_cm: { $gt: 25 } } )

2.3.1和2.3.2結果見下圖

當然也可以使用多條件匹配查詢，就是下文要講到的$elemMatch查詢。 
大概格式和說明如下，比如 db.inventory.find( { dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } } )  說明要查詢dim_cm中存在元素值大於22小於30的檔案。 
具體看下文。

// 範例查詢語句，意思是說查詢instock陣列中的元素存在等於 { warehouse: "A", qty: 5 } 的檔案。  
db.inventory.find( { "instock": { warehouse: "A", qty: 5 } } )
// 意思是說查詢instock陣列中元素物件中的qty 存在大於等於20的檔案。
db.inventory.find( { 'instock.qty': { $lte: 20 } } )

// 官方標準語法
{ <field>: { $elemMatch: { <query1>, <query2>, ... } } }
// field是陣列欄位名，在$elemMatch中傳入查詢條件，可多個，用逗號隔開。 

// 先插入資料
db.scores.insertMany( [
{ _id: 1, results: [ 82, 85, 88 ] },
{ _id: 2, results: [ 75, 88, 89 ] }
] )

// 來個最基本的$elemMatch使用演示
// 語句說明，查詢 results陣列中存在大於等於80且小於85的元素的檔案。（只要元素中有一個匹配，那麼這個元素所在的陣列的檔案就會返回）
db.scores.find(
   { results: { $elemMatch: { $gte: 80, $lt: 85 } } }
)

// 返回結果， 
{ "_id" : 1, "results" : [ 82, 85, 88 ] }

// 說明： _id=2的資料，沒有任何一個元素值在80~85之間，所以不返回。

// 1. 插入資料
db.survey.insertMany( [
   { "_id": 1, "results": [ { "product": "abc", "score": 10 },
                            { "product": "xyz", "score": 5 } ] },
   { "_id": 2, "results": [ { "product": "abc", "score": 8 },
                            { "product": "xyz", "score": 7 } ] },
   { "_id": 3, "results": [ { "product": "abc", "score": 7 },
                            { "product": "xyz", "score": 8 } ] },
   { "_id": 4, "results": [ { "product": "abc", "score": 7 },
                            { "product": "def", "score": 8 } ] }
] )

// 查詢演示， 這裡是查詢results中元素含有 { product: "xyz", score: { $gte: 8 }  --- 也就是product = xyz, score ≥ 8的元素。 只要陣列中含有匹配的元素，該陣列所在的檔案返回。
db.survey.find(
   { results: { $elemMatch: { product: "xyz", score: { $gte: 8 } } } }
)

// 查詢結果  --- 可以看到 product = xyz， score≥8，所以這條 id=3的檔案被返回。 
{ "_id" : 3, "results" : [ { "product" : "abc", "score" : 7 },
                           { "product" : "xyz", "score" : 8 } ] }

// 補充，只要陣列中的元素有至少一個匹配查詢規則（$elemMatch中的條件）,那麼該陣列所在的檔案就返回，不管陣列中其他的元素怎樣。

// 不帶$elemMatch 查詢results.product不等於xyz的檔案，是要全部元素做匹配，如果有一個元素不匹配，那條資料所在的檔案就不返回。 
db.survey.find(
   { "results.product": { $ne: "xyz" } }
)
// 返回結果
{ "_id" : 4, "results" : [ { "product" : "abc", "score" : 7 },
                           { "product" : "def", "score" : 8 } ] }


// 帶$elemMatch 
db.survey.find(
   { "results": { $elemMatch: { product: { $ne: "xyz" } } } }
)
// 返回結果，說明，因為是要查詢陣列results中存在元素product != xyz的檔案，只要有一個元素的product != xyz，那麼這個元素所在的陣列的檔案就會返回。 下面 id=1\2\3的第一個元素都為abc， != xyz， 所以返回，哪怕第二個元素的product == xyz。 
{ "_id" : 1, "results" : [ { "product" : "abc", "score" : 10 },
                           { "product" : "xyz", "score" : 5 } ] }
{ "_id" : 2, "results" : [ { "product" : "abc", "score" : 8 },
                           { "product" : "xyz", "score" : 7 } ] }
{ "_id" : 3, "results" : [ { "product" : "abc", "score" : 7 },
                           { "product" : "xyz", "score" : 8 } ] }
{ "_id" : 4, "results" : [ { "product" : "abc", "score" : 7 },
                           { "product" : "def", "score" : 8 } ] }

// 官方標準語法定義
db.collection.update(
   <query>, // 要更新的檔案的查詢語句
   <update>, // 要更新的內容
   {
     upsert: <boolean>,  // 可選，true時開啟，存在則更新，否則新增，預設為False。
     multi: <boolean>, // 可選， true時開啟，批次更新符合條件的檔案，否則只更新第一條符合條件的檔案，預設false。
     writeConcern: <document>, // 可選，寫入策略。比如writeConcern:{w:1}, w:1 是預設的writeConcern，表示資料寫入到Primary就向用戶端傳送確認。 這個一般可以先不管，除非有需要再去專門看，否則不帶此引數。 
     collation: <document>,  // 可選，根據不同的語言客製化排序規則，比如{collation: {locale: "zh"}} 代表檔案處理時，按照中文拼音排序規則來排序處理。 預設情況下，是按照欄位值的普通的二機制字串來排序。 可以先忽略。
     arrayFilters: [ <filterdocument1>, ... ],  // 可選，這個對於陣列欄位的更新很有用，尤其是隻需要更新陣列中的符合條件的個別元素。  等下下文會有使用演示。 
     hint:  <document|string>, // 可選， 4.2 版本後新增的東西  強制某個欄位使用索引。 儘管mongodb會自動優化處理，但為了避免某個欄位沒有使用索引，可以強制指定。
     let: <document> // 可選， 5.0 版本後新增的東西 一個變數定義選項，可以讓命令的可讀性得到提升，
   }
)

// 上面的let 選項，如下是一個簡易範例。
假設有這幾條資料
db.cakeFlavors.insertMany( [
   { _id: 1, flavor: "chocolate" },
   { _id: 2, flavor: "strawberry" },
   { _id: 3, flavor: "cherry" }
] )

// 執行下述語句，用了let 分別定義了 targetFlavor變數，值為cherry， newFlavor變數，值為 orange。  在前面的 query/update 中，對應的匹配值和新的set的值，是用了let中定義的變數名來佔位。  
db.cakeFlavors.update(
   { $expr: { $eq: [ "$flavor", "$$targetFlavor" ] } },
   [ { $set: { flavor: "$$newFlavor" } } ],
   { let : { targetFlavor: "cherry", newFlavor: "orange" } }
)
上面的意思就是查詢flalvor等於targetFlavor(let中定義的變數）的值（也就是cherry）的檔案，然後把flavor的值更新成 newFlavor(let中定義的變數)的值（即 orange）。 

// 讓我們先插入一些資料 
db.students.insertMany( [
   { "_id" : 1, "grades" : [ 85, 80, 80 ] },
   { "_id" : 2, "grades" : [ 88, 90, 92 ] },
   { "_id" : 3, "grades" : [ 85, 100, 90 ] }
] )

// 注意，這裡用的updateOne，只更新一條。  
// 查詢_id=1, grades陣列中有80的檔案。把grades中第一個匹配的元素（就是值為80）替換成 82
db.students.updateOne(
   { _id: 1, grades: 80 },
   { $set: { "grades.$" : 82 } }
) 

// 更新完畢後，可以看到id=1的資料中的grades，第一個80變成82了，後面的80沒變。 這就是$，代表佔位匹配的第一個元素位置（不是陣列的第一個元素）。
{ "_id" : 1, "grades" : [ 85, 82, 80 ] }
{ "_id" : 2, "grades" : [ 88, 90, 92 ] }
{ "_id" : 3, "grades" : [ 85, 100, 90 ] }

// 有人說，如果我要更新所有grades含有 90的陣列的第一個匹配元素呢？請看下面語句。
//  使用update，開啟批次更新（ {multi:true}）。 查詢grades存在90的檔案，並把每個檔案中的第一個90替換成82.
db.students.update(
   { grades: 90 },
   { $set: { "grades.$" : 82 } },
   {multi:true}
)

// 執行後的結果
{ "_id" : 1, "grades" : [ 85, 82, 80 ] }
{ "_id" : 2, "grades" : [ 88, 82, 92 ] }
{ "_id" : 3, "grades" : [ 85, 100, 82] }

// 先執行一下把Students的資料清空
db.students.remove({}) 

// 插入帶物件的陣列資料
db.students.insertMany( [
{"_id" : 4,
    "grades" : [
    { "grade" : 80, "mean" : 75, "std" : 8 }, 
    { "grade" : 85, "mean" : 90, "std" : 6 }, 
    { "grade" : 85, "mean" : 85, "std" : 8 }
    ]
},
{
  "_id": 5,
  "grades": [
     { "grade": 80, "mean": 75, "std": 8 },
     { "grade": 85, "mean": 90, "std": 5 },
     { "grade": 90, "mean": 85, "std": 3 }
  ]
}
])

// 執行updateOne 
db.students.updateOne(
   { _id: 4, "grades.grade": 85 },
   { $set: { "grades.$.std" : 10 } }
)

// 還是一樣，先清空下資料
db.students.remove({})
// 插入演示資料
db.students.insertMany( [
   {
      "_id" : 1,
      "grades" : [
         { "grade" : 80, "mean" : 75, "std" : 8 },
         { "grade" : 85, "mean" : 90, "std" : 6 },
         { "grade" : 85, "mean" : 85, "std" : 8 }
      ]
   },
   {
      "_id" : 2,
      "grades" : [
         { "grade" : 90, "mean" : 75, "std" : 8 },
         { "grade" : 87, "mean" : 90, "std" : 5 },
         { "grade" : 85, "mean" : 85, "std" : 6 }
      ]
   }
] )

// 更新所有grades陣列中含有grade大於80的檔案，使用grades.$[].std表示更新每個匹配檔案中的所有元素的std欄位值。  這裡是統一改成10。
db.students.updateMany(
   {"grades":{$elemMatch:{"grade": {$gt:80}}}},
   { $set: { "grades.$[].std" : 10 } },
)

結果看下圖

db.students.updateMany(
   {"grades":{$elemMatch:{"grade": {$gt:80}}}},
   { $set: { "grades.$[]" : "隨便你寫個值" } }, // 這裡grades 假設是一個字串陣列。 
)

db.collection.updateMany(
   { <query conditions> },  // 查詢條件
   { <update operator>: { "<array>.$[<identifier>]" : value } },  // 更新內容
   { arrayFilters: [ { <identifier>: <condition> } ] }  // 陣列過濾條件
)

// 先清空下資料
db.students.remove({})

// 插入資料
db.students.insertMany( [
   { "_id" : 1, "grades" : [ 95, 92, 90 ] },
   { "_id" : 2, "grades" : [ 98, 100, 102 ] },
   { "_id" : 3, "grades" : [ 95, 110, 100 ] }
] )

// 使用$[<identifier>] 更新 
//  查詢所有，把grades中≥100的值全部換成333。 
db.students.updateMany(
   { },
   { $set: { "grades.$[element]" : 333 } },
   { arrayFilters: [ { "element": { $gte: 100 } } ] }
)

注意： identifier的名稱可以是任意，但是$set和arrayFilters中的名稱要一致。 

執行後的資料結果如下。

// 還是先清空資料
db.students.remove({})

// 插入資料
db.students.insertMany( [
{  "_id" : 1,
   "grades" : [
      { "grade" : 80, "mean" : 75, "std" : 5 },
      { "grade" : 85, "mean" : 100, "std" : 4 },
      { "grade" : 85, "mean" : 100, "std" : 5 }
   ]
},
{
   "_id" : 2,
   "grades" : [
      { "grade" : 90, "mean" : 100, "std" : 5 },
      { "grade" : 87, "mean" : 100, "std" : 3 },
      { "grade" : 85, "mean" : 100, "std" : 4 }
   ]
}
] )

//  查詢所有，把所有grades中的grade ≥ 85的元素中的mean更新為111 
db.students.updateMany(
   { },
   { $set: { "grades.$[elem].mean" : 111 } },
   { arrayFilters: [ { "elem.grade": { $gte: 85 } } ] }
)

注意： arrayFilters的elem要和set中的$[elem]中的elem一致。 是一個識別符號。 可以任意，但要一致。 

執行後結果如下圖

AddToSet
// 語法格式：
{ $addToSet: { <field1>: <value1>, ... } } // 欄位名：值 

// 插入一條演示資料
db.inventory.insertOne(
   { _id: 1, item: "polarizing_filter", tags: [ "electronics", "camera" ] }
)

// 使用addToSet 新增一個元素到Tags中。 
db.inventory.updateOne(
   { _id: 1 },
   { $addToSet: { tags: "accessories" } }
)

// 作用，刪除陣列中的第一個或者最後一個元素。
// 語法格式
{ $pop: { <field>: <-1 | 1>, ... } }
其中 -1， 1 分別代表陣列的第一個元素和最後一個元素

// 插入資料
db.students.insertOne( { _id: 1, scores: [ 8, 9, 10 ] } )

// 刪除scores陣列的第一個元素（-1）
db.students.updateOne( { _id: 1 }, { $pop: { scores: -1 } } )

// 再次檢視 結果如下
{ _id: 1, scores: [ 9, 10 ] } 
可以看到第一個元素 8 已經被刪掉。

// 作用： 把一個元素加入到陣列中。
// 語法
{ $push: { <field1>: <value1>, ... } }

// 插入資料
db.students.insertMany( [
   { _id: 2, scores: [ 45, 78, 38, 80, 89 ] } ,
   { _id: 3, scores: [ 46, 78, 38, 80, 89 ] } ,
   { _id: 4, scores: [ 47, 78, 38, 80, 89 ] }
] )

// 批次更新，對每個檔案都往scores中追加一個元素 95. 
db.students.updateMany(
   { },
   { $push: { scores: 95 } }
)

// 再次查詢 結果
[
   { _id: 1, scores: [ 44, 78, 38, 80, 89, 95 ] },
   { _id: 2, scores: [ 45, 78, 38, 80, 89, 95 ] },
   { _id: 3, scores: [ 46, 78, 38, 80, 89, 95 ] },
   { _id: 4, scores: [ 47, 78, 38, 80, 89, 95 ] }
]

// 作用：刪除陣列中的指定元素（通過查詢條件），
// 注意和 $pullAll的區別， pullAll是刪除所有指定值元素， pull是傳入查詢條件，刪除符合條件的元素。 
// 語法格式
{ $pull: { <field1>: <value|condition>, <field2>: <value|condition>, ... } }

// 插入資料 
db.stores.insertMany( [
   {
      _id: 1,
      fruits: [ "apples", "pears", "oranges", "grapes", "bananas" ],
      vegetables: [ "carrots", "celery", "squash", "carrots" ]
   },
   {
      _id: 2,
      fruits: [ "plums", "kiwis", "oranges", "bananas", "apples" ],
      vegetables: [ "broccoli", "zucchini", "carrots", "onions" ]
   }
] )

// 刪掉fruits中所有apples, oranges元素，刪掉vegatables中所有carrots元素。 
db.stores.updateMany(
    { },
    { $pull: { fruits: { $in: [ "apples", "oranges" ] }, vegetables: "carrots" } }
)

// 執行後結果 
{
  _id: 1,
  fruits: [ 'pears', 'grapes', 'bananas' ],
  vegetables: [ 'celery', 'squash' ]
},
{
  _id: 2,
  fruits: [ 'plums', 'kiwis', 'bananas' ],
  vegetables: [ 'broccoli', 'zucchini', 'onions' ]
}

// 作用，傳入指定值，刪除陣列中元素為指定值的所有元素，和$pull的區別是，pull是依賴於傳入的查詢條件，刪除匹配查詢條件的元素。 
// 語法格式
{ $pullAll: { <field1>: [ <value1>, <value2> ... ], ... } }

// 插入資料
db.survey.insertOne( { _id: 1, scores: [ 0, 2, 5, 5, 1, 0 ] } )

// 執行
db.survey.updateOne( { _id: 1 }, { $pullAll: { scores: [ 0, 5 ] } } )


// 刪除 0，5的元素，再次查詢，結果如下
{ "_id" : 1, "scores" : [ 2, 1 ] }