Insert Operation

通過insertOne()的方式將單個文檔插入到集合中，如果集合不存在將會自動創(chuàng)建。

db.inventory.insertOne([
   { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } }
])

通過InsertMany()的方式可以將多個文檔插入到集合中

db.inventory.insertMany([
   { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } },
   { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } },
   { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }
])

插入行為：

• _id：插入時未指定_id值，系統(tǒng)將自動分配一個ObjectId對象
• 原子性：MongoDB中所有寫操作都是單個文檔級別的原子操作，如果批量操作時有一個文檔插入失敗，那么在這個文檔之前的所有文檔都會插入成功，后續(xù)的文檔全部失敗
• 插入校驗：插入數(shù)據(jù)時，MongoDB會做基本的檢查：檢查文檔結(jié)構(gòu)，檢查大小。MongoDB限制所有文檔都必須小于16MB，如果要查看BSON文檔的大小，可以執(zhí)行Object.bsonsize()
• writeConcern：可選參數(shù)。在副本集架構(gòu)中，可以指定為majority將數(shù)據(jù)插入大多數(shù)節(jié)點[view]
• ordered：批量插入時，如果為true則有序插入，發(fā)生錯誤則直接返回；false則無序插入，發(fā)生錯誤則繼續(xù)處理后續(xù)文檔。默認為true

更多內(nèi)容請參考：
db.collection.insertOne()
db.collection.insertMany()

Query Operation

MongoDB中使用find()來進行查詢，查詢返回集合中的文檔子集，查詢時可以指定限定條件來篩選所需的數(shù)據(jù)，條件為空則返回整個集合的文檔
示例數(shù)據(jù)

[
    { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
    { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },
    { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
    { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
    { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }
]

查詢年齡為qty為50且status為A的文檔

db.user.find({"qty" : 27 , "status" : "A"})

查詢size嵌套文檔

db.user.find({ size: { h: 14, w: 21, uom: "cm" } })
db.user.find({ "size.uom": "in" })

如果只想返回部分文檔列，可以在查詢中指定，例如只返回name列：db.user.find({},{"name" : 1})。_id總是默認輸出

查詢操作符

查詢age大于等于18，小于等于30的文檔

db.mycoll.find({"age" : {"$gte" : 18 , "$lte" : 30}})

查詢number為725，542，290的文檔

db.mycoll.find({"number" : {"$in" : [725,542,290]}})

查詢number不為725，542，290的文檔

db.mycoll.find({"number" : {"$nin" : [725,542,290]}})

查詢number為725或name為lhx的文檔

db.mycoll.find({"$or" : [{"number" : 725} , {"name" : "lhx"}]})

查詢包含apple和banana的數(shù)組

db.mycoll.find({"fruit" : {$all : ["apple" , "banana"]}})

查詢數(shù)組長度為3的數(shù)組

db.mycoll.find({"fruit" : {"$size" : 3}})

查詢第11-20條的留言

db.mycoll.find(criteria , {"comments" : {"$slice" : [10,10]}})

針對null類型的查詢

在針對數(shù)據(jù)類型為null的字段進行查詢時，如果指定了一個不存在的鍵，則會返回整個集合不包含該鍵的文檔

> db.mycoll.find({"a" : null})
{"_id" : ObjectID("4bados9df830a0ok0d52"),"a" : null}

查詢不存在的b字段

> db.mycoll.find({"b" : null})
{"_id" : ObjectID("4bados9df830a0ok0d52"),"a" : null}
{"_id" : ObjectID("4bados9df830a0ok0d53"),"a" : 1}
{"_id" : ObjectID("4bados9df830a0ok0d54"),"a" : 2}

如果僅想檢查該鍵的值是否為null，可以設(shè)置$exists條件判定鍵值是否存在

db.mycoll.find({"b" :{$in : [null] , "$exists" : true}})

針對正則表達式的查詢

MongoDB使用perl兼容的正則表達式(PCRE)庫來匹配正則表達式，任何PCRE支持的正則表達式語法都能被MongoDB接受。建議使用正則表達式之前現(xiàn)在JavaScripts shell中檢查一下語法

查詢name為joe的文檔(正則表達式不區(qū)分大小寫)

db.mycoll.find({"name": /joe/i})

數(shù)組與范圍查詢

目前存在如下文檔：
{"x" : 5}
{"x" : 15}
{"x" : 25}
{"x" : [5 , 25]}

如果現(xiàn)在要查詢x的值位于10-20之間的所有文檔，通?？赡軙ㄟ^db.mycoll.find({"x" : {"$gt" : 10 , "lt" : 20}})的方式來查詢，希望返回{"x" : 15}。但是實際上會返回兩個文檔：
{"x" : 15}
{"x" : [5 , 25]}

造成數(shù)組也返回的原因是因為25大于10，而且5也小于20，因此也符合查詢條件。針對這種情況可以進行如下設(shè)置

• 如果希望排除非數(shù)組，可以通過$elemMatch要求MongoDB同時使用查詢條件的兩個語句與一個組元素進行比較

db.mycoll.find({"x" : {"\$elemMatch" : {"\$gt" : 10 , "\$lt" : 20}})

• 如果查詢字段創(chuàng)建了索引，可以使用min()和max()將查詢范圍限制為lt的值

db.mycoll.find({"x" : {"$gt" : 10 , "lt" : 20}}).min({"x" : 10}).max({"x" : 20})

$where查詢

$where子句可以在查詢中執(zhí)行任意的javascript，這樣就可以實現(xiàn)更多操作。但$where子句比較慢且不走索引，因此不到迫不得已不建議使用該方式。

比如查詢返回兩個鍵值相同的文檔，在當前的環(huán)境中沒有提供相關(guān)操作符。這里可以用$where借助javascript實現(xiàn)

db.mycoll.find({"where" : function(){
    for (var current in this) {
         for (var other in this) {
              if (current != other && this[currnet] == this[other]) {
                  return true;
              }
         }
     }
     return false;
}});

游標

數(shù)據(jù)庫使用游標返回find的查詢結(jié)果，客戶端對游標的實現(xiàn)通?？梢詫ψ罱K結(jié)果進行有效的控制。

定義一個變量來保存find結(jié)果

var cursor = db.mycoll.find();

cursor.hasNext()檢查是否還存在下一個值，cursor.next()獲得該值

while (cursor.hasNext()) {
    obj=cursor.next();
    print(obj)
}

游標還實現(xiàn)了Javascripts的迭代器接口，所以可以在forEach中使用

cursor.forEach(function(x)) {
    print(x.name);
})

調(diào)用find時，并不會立即查詢數(shù)據(jù)庫，而是等待真正開始要獲取結(jié)果時才會立即獲取前100個結(jié)果或4MB數(shù)據(jù)(兩者中最小)，這樣下次調(diào)用next或者hasNext就不用再連接服務(wù)器獲取結(jié)果了。當?shù)谝唤M數(shù)據(jù)獲取結(jié)束后，會再次用getMore的方式請求更多結(jié)果。

結(jié)果集限制

limit可以限制返回結(jié)果的數(shù)量，例如只返回三條數(shù)據(jù)

db.mycoll.find().limit(3)

Skip則可以略過指定的數(shù)據(jù)，例如略過前三條數(shù)據(jù)

db.mycoll.find().skip(3)

如果將skip用于過濾大量數(shù)據(jù)，則性能會比較緩慢。例如對數(shù)據(jù)進行分頁。最簡單的數(shù)據(jù)分頁方式就是通過skip不斷修改偏移量結(jié)合limit實現(xiàn)

db.mycoll.find().limit(100)
db.mycoll.find().skip(100).limit(100)
db.mycoll.find().skip(200).limit(100)

對于數(shù)據(jù)分頁可采用下列方式，而不是使用skip

var page1 = db.mycoll.find().sort({"date" : -1}).limit(100)
var latest = null
while (page1.hasNext()) {
     latest = page1.next();
     display(latest)
}
var page2 = db.mycoll.find({"date" : {$gt" : latest.date}});
page2.sort({"date" : -1}).limit(100)

sort接收一個鍵值對對象作為參數(shù)，鍵對應(yīng)文檔的鍵名，值代表排序方向，1表示升序，-1表示倒序

db.mycoll.find().sort({username :1 , age : -1})

如果一個鍵的值是多種類型的，其排序順序是預(yù)先定義好的。優(yōu)先級從小到大順序如下：

1. 最小值
2. Null
3. 數(shù)字
4. 字符串
5. 對象/文檔
6. 數(shù)組
7. 二進制數(shù)據(jù)
8. 對象ID
9. 布爾型
10. 日期型
11. 時間戳
12. 正則表達式
13. 最大值

高級查詢選項

大部分驅(qū)動程序都提供了輔助函數(shù)，用于向查詢添加各種選項

db.user.find()._addSpecial('$showDiskLoc',true)

查詢一致性

在我們通過查詢獲取數(shù)據(jù)之后再對數(shù)據(jù)進行處理并保存回數(shù)據(jù)庫時，結(jié)果集比較大的話，MongoDB可能存在多次返回同一個文檔。因為文檔預(yù)留空間不足，導(dǎo)致原位置無法存放，MongoDB通常會將它們移動到集合尾端，當游標掃描到尾端時就會再次返回這部分數(shù)據(jù)。

應(yīng)對這個問題可以設(shè)置snapshot，查詢就在_id上遍歷執(zhí)行，保證每個文檔只返回一次，但快照會使查詢變慢，只在必要時使用，例如mongodump備份數(shù)據(jù)庫。

db.user.find().snapshot();

Update Operation

db.collection.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ]
   }
)

db.collection.updateOne(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ]
   }
)

db.collection.updateMany(
   <filter>,
   <update>,
   {
     upsert: <boolean>,
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ]
   }
)

db.collection.findOneAndUpdate(
   <filter>,
   <update>,
   {
     projection: <document>,
     sort: <document>,
     maxTimeMS: <number>,
     upsert: <boolean>,
     returnNewDocument: <boolean>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ]
   }
)

• filter：查詢過濾器
• update：如果是要替換文檔中的字段，可以使用文檔替換模式，如果在原字段進行修改需要使用操作符
• projection：返回文檔的字段
• sort：指定排序規(guī)則
• maxTimeMS：限定操作時間，單位為毫秒，超時則報錯
• upsert：文檔不存在時，自動創(chuàng)建一個新文檔，默認為false
• returnNewDocument：返回更新前的文檔還是更新后的文檔，默認為false，返回更新前的文檔
• collation：collation用于指定字符串比較規(guī)則
• arrayFilters：數(shù)組過濾器
• writeConcern：寫入關(guān)注級別
• multi：是否批量修改，默認為false，更新只能對符合匹配條件的第一個文檔進行更新

默認情況下，更新只能對符合匹配條件的第一個文檔執(zhí)行操作。如果需要對多個文檔進行操作，需要將update的第四個參數(shù)修改為true。為了安全起見，建議顯示指定該參數(shù)。如果想知道更新了多少文檔可以執(zhí)行g(shù)etLastError

db.runCommand({getLastError:1})

文檔替換

當前數(shù)據(jù)庫存在下列文檔記錄

{
  "_id" : ObjectId("5bf4f9936dd981d267ddd1b0"),
  "name" : "joe",
  "friends" : 32,
  "enemies" : 2
}

現(xiàn)在計劃將friends和enemies劃分到relationships的子文檔中，可以做如下修改

>var joe=db.U_Test.findOne({"name":"joe"})
>joe.relationships={"frieds":joe.friends,"enemies":joe.enemies}
>delete joe.friends
>delete joe.enemies
>db.U_Test.updateOne({"_id":ObjectId("5bf4f9936dd981d267ddd1b0")},joe)
{
  "_id" : ObjectId("5bf4f9936dd981d267ddd1b0"),
  "name" : "joe",
  "relationships" : {
    "friends" : 32,
    "enemies" : 2
  }
}

修改器

填充因子

MongoDB不得不移動一個新文檔時，例如update使原有文檔變大，它會修改集合的填充因子，填充因子是MongoDB為每個新文檔預(yù)留的增長空間?？梢詧?zhí)行db.collection.status()查看填充因子。隨著不斷的文檔移動，填充因子會越來越大，反之則緩慢降低。

移動文檔是非常慢的，MongoDB必須將文檔原本所占的空間釋放掉，然后將文檔寫入另一片區(qū)域。因此盡量讓填充因子接近1。如果日志中頻繁出現(xiàn)was empty,skipping ahead的字眼，說明數(shù)據(jù)庫目前在頻繁移動文檔，存在較多碎片，意味著存在性能問題。

如果你的集合插入和刪除時會進行大量的移動或者經(jīng)常打亂數(shù)據(jù)，可以用usePowerOf2Sizes選項提高磁盤復(fù)用率?？梢酝ㄟ^collMod命令來設(shè)置該選項：

db.runCommand({"collMod":collection,"usePowerOf2Sizes":true})

這個集合之后進行的所有空間分配，得到的塊都是2的冪。只會影響新分配的記錄，不對現(xiàn)有數(shù)據(jù)產(chǎn)生影響。該選項會導(dǎo)致初始空間不再那么高效，建議在需要經(jīng)常打亂數(shù)據(jù)的集合上使用

upsert

upset是一種特殊更新，如果沒有按條件找到對應(yīng)文檔，則以更新條件和更新文檔為基礎(chǔ)創(chuàng)建一個新的文檔,找到則正常更新

db.analytics.update({"url":"/blog"},{"$inc":{"pageviews":1}},true)

save

save是一個shell函數(shù)，傳入一個文檔，如果文檔不存在，它會自動創(chuàng)建文檔，如果文檔存在，它會更新這個文檔。要是這個文檔帶有_id鍵，save會調(diào)用upsert，否則調(diào)用insert

findAndModify

findAndModify具有原子性，能夠在一個操作中返回匹配結(jié)果以及更新，適用于大批量查詢更新的場景。

process=db.runCommand({"findAndModify":"processes",
"query":{"status":"READY"},
"sort":{"priority":-1},
"update":{"$set":{"status":"RUNNING"}}}
).value

findAndModify支持很多字段：

• query：檢索文檔的條件
• sort：排序結(jié)果的條件
• update：用于對文檔進行匹配更新
• remove：布爾類型，表示是否刪除文檔
• new：布爾類型，表示返回更新前的文檔還是更新后的文檔，默認為更新前
• fields：文檔中需要返回的字段
• upset：布爾類型，值為true則使用upset，默認為false

Delete Operation

db.collection.remove()

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

• query:刪除文檔的條件，如果不指定則刪除整個集合
• justOne：是否只刪除一個文檔，如果為true則只刪除一個，false則刪除所有匹配的文檔
• writeConcern：寫入確認，指定為majority可以確保集群中大多數(shù)節(jié)點都已刪除

db.collection.deleteMany()

db.collection.deleteMany(
   <filter>,
   {
      writeConcern: <document>,
      collation: <document>
   }
)

db.collection.deleteOne()

db.collection.deleteOne(
   <filter>,
   {
      writeConcern: <document>,
      collation: <document>
   }
)

• collation: collation用于指定字符串比較規(guī)則

在3.2版本中通過findOneAndDelete()也可以對文檔進行查找刪除，并返回刪除的文檔信息

db.collection.findOneAndDelete(
   <filter>,
   {
     projection: <document>,
     sort: <document>,
     maxTimeMS: <number>,
     collation: <document>
   }
)

• projection：選擇返回的文檔字段，省略則返回全部字段
• sort：指定排序方式
• maxTimeMS：指定操作時間限制，超過則報錯，單位為毫秒

Bulk Write

MongoDB3.2支持通過db.collection.bulkWrite()的方式執(zhí)行批量插入，更新和刪除操作。Bulk write可以有序操作也可以無序操作，有序操作則按順序執(zhí)行操作，如果發(fā)生錯誤，不處理后續(xù)的其它操作；無序操作時，MongoDB可以并行執(zhí)行，發(fā)生錯誤時將繼續(xù)處理其它操作。Bulk write默認為有序操作，無序操作需要設(shè)置ordered:false

bulkWrite()支持下列寫操作：

• 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);
}

針對分片環(huán)境的批量插入可能影響集群性能，建議考慮下列策略：1. 預(yù)分片 2.無序操作