Table of Contents
1 基本索引
在數(shù)據(jù)庫(kù)開發(fā)中索引是非常重要的，對(duì)于檢索速度，執(zhí)行效率有很大的影響。本 文主要描述了MongoDB中索引的使用，以及通過分析執(zhí)行計(jì)劃來提高數(shù)據(jù)庫(kù)檢索 效率。
作為事例，在數(shù)據(jù)庫(kù)中插入百萬(wàn)條數(shù)據(jù)，用于分析
>
for
(i = 0; i < 1000000; i++) {
"i"
: i,
"username"
:
"user"
+ i,
"age"
: Math.floor(Math.random() * 120),
"created"
:
new
Date
()
}
在MongoDB中，所有查詢操作，都可以通過執(zhí)行explain()函數(shù)來實(shí)現(xiàn)執(zhí)行的分析， 通過執(zhí)行查詢username為user99999的用戶，并執(zhí)行查詢分析，可以得出如下結(jié) 果：
> db.users.find({
"username"
:
"user99999"
}).explain()
{
"cursor"
:
"BasicCursor"
,
"isMultiKey"
:
false
,
"n"
: 1,
"nscannedObjects"
: 1000000,
"nscanned"
: 1000000,
"nscannedObjectsAllPlans"
: 1000000,
"nscannedAllPlans"
: 1000000,
"scanAndOrder"
:
false
,
"indexOnly"
:
false
,
"nYields"
: 1,
"nChunkSkips"
: 0,
"millis"
: 561,
"indexBounds"
: {
},
"server"
:
"WallE.local:27017"
}
其中，“n”表示查找到數(shù)據(jù)的個(gè)數(shù)，“nscanedObjects”表示本次查詢需要掃描的 對(duì)象個(gè)數(shù)，“milis”表示此次查詢耗費(fèi)的時(shí)間，可以看到，這次查詢相當(dāng)于對(duì)整 個(gè)數(shù)據(jù)表進(jìn)行了遍歷，共一百萬(wàn)條數(shù)據(jù)，找到其中一條數(shù)據(jù)，耗費(fèi)時(shí)間為561毫 秒。
我們也可以使用limit來限制查找的個(gè)數(shù)，從而提升效率，例如：
> db.users.find({
"username"
:
"user99999"
}).limit(1).explain()
{
"cursor"
:
"BasicCursor"
,
"isMultiKey"
:
false
,
"n"
: 1,
"nscannedObjects"
: 100000,
"nscanned"
: 100000,
"nscannedObjectsAllPlans"
: 100000,
"nscannedAllPlans"
: 100000,
"scanAndOrder"
:
false
,
"indexOnly"
:
false
,
"nYields"
: 0,
"nChunkSkips"
: 0,
"millis"
: 48,
"indexBounds"
: {
},
"server"
:
"WallE.local:27017"
}
可以看到，這里這次查詢只掃描了十萬(wàn)條數(shù)據(jù)，并且耗費(fèi)時(shí)間大概也只有之前的 十分之一。這是因?yàn)椋捎谙拗屏吮敬尾樵冃枰@取結(jié)果的個(gè)數(shù)，MongoDB在遍 歷數(shù)據(jù)的過程中一旦發(fā)現(xiàn)了找到了結(jié)果就直接結(jié)束了本次查詢，因此效率有了較 大提升。但是這種方式的并不能夠解決效率問題，如果需要查詢的username為 user999999，那么MongoDB仍然需要遍歷整個(gè)數(shù)據(jù)庫(kù)才能得到結(jié)果。
同其他數(shù)據(jù)庫(kù)一樣，MongoDB也支持索引來提高查詢速度，為了提高username的 查詢速度，在該字段上建立一個(gè)索引：
> db.users.ensureIndex({
"username"
: 1})
執(zhí)行完該命令后，就在users這個(gè)集合中為username新建了一個(gè)索引，這個(gè)索引 字段可以在db.system.indexes集合中找到：
> db.system.indexes.find()
{
"v"
: 1,
"key"
: {
"_id"
: 1 },
"ns"
:
"test.users"
,
"name"
:
"_id_"
}
{
"v"
: 1,
"key"
: {
"username"
: 1 },
"ns"
:
"test.users"
,
"name"
:
"username_1"
}
值得注意的是，從以上查詢中可以看到，每個(gè)數(shù)據(jù)集合都有一個(gè)默認(rèn)的索引字段， 就是_id字段，這個(gè)字段在該數(shù)據(jù)集合建立的時(shí)候就會(huì)創(chuàng)建。
索引建立之后，再來看下執(zhí)行效率：
> db.users.find({
"username"
:
"user99999"
}).explain()
{
"cursor"
:
"BtreeCursor username_1"
,
"isMultiKey"
:
false
,
"n"
: 1,
"nscannedObjects"
: 1,
"nscanned"
: 1,
"nscannedObjectsAllPlans"
: 1,
"nscannedAllPlans"
: 1,
"scanAndOrder"
:
false
,
"indexOnly"
:
false
,
"nYields"
: 0,
"nChunkSkips"
: 0,
"millis"
: 0,
"indexBounds"
: {
"username"
: [
[
"user99999"
,
"user99999"
]
]
},
"server"
:
"WallE.local:27017"
}
可以看到，這次MongoDB程序幾乎是一瞬間就找到結(jié)果，并且掃描的對(duì)象個(gè)數(shù)為1， 可以看到，這次查詢直接就找到了需要的結(jié)果。
對(duì)比第一次沒有建立索引時(shí)的執(zhí)行結(jié)果，可以看到，第一個(gè)字段“cursor”值也有 所變化。作為區(qū)分，第一個(gè)字段為“BasicCursor”時(shí)就表示當(dāng)前查詢沒有使用索 引，而建立索引后，該值為“BtreeCursor username_1”，也可以看出來MongoDB 使用的是B樹來建立索引。
2 聯(lián)合索引
通過使用索引，數(shù)據(jù)庫(kù)會(huì)對(duì)數(shù)據(jù)庫(kù)中索引中所表示的字段保持已排序狀態(tài)，也就 是說，我們能夠方便的針對(duì)該字段進(jìn)行排序查詢?nèi)纾?
> db.users.find().sort({
"username"
: 1})
...
MongoDB能夠很快返回結(jié)果，但是這種幫助只能在查詢字段在首位的情況下才能 生效，如果該字段不在查詢的首位，就可能無(wú)法使用到該索引帶來的好處了，如：
> db.users.find().sort({
"age"
: 1,
"username"
: 1})
error: {
"$err"
:
"too much data for sort() with no index. add an index or specify a smaller limit"
,
"code"
: 10128
}
查詢字段第一位為“age”，這個(gè)時(shí)候，MongoDB就會(huì)提示錯(cuò)誤信息。
為了解決這類問題，MongoDB同其他數(shù)據(jù)庫(kù)一樣，也提供了聯(lián)合索引的操作，同 樣通過ensureIndex函數(shù)來實(shí)現(xiàn)：
> db.users.ensureIndex({
"age"
: 1,
"username"
: 1})
執(zhí)行這個(gè)操作可能需要耗費(fèi)較長(zhǎng)時(shí)間，執(zhí)行成功后，仍然可以通過查詢 db.system.indexes集合來查看索引建立情況：
> db.system.indexes.find()
{
"v"
: 1,
"key"
: {
"_id"
: 1 },
"ns"
:
"test.users"
,
"name"
:
"_id_"
}
{
"v"
: 1,
"key"
: {
"username"
: 1 },
"ns"
:
"test.users"
,
"name"
:
"username_1"
}
{
"v"
: 1,
"key"
: {
"age"
: 1,
"username"
: 1 },
"ns"
:
"test.users"
,
"name"
:
"age_1_username_1"
}
可以看到，剛才的操作建立了一個(gè)名字為“age_1_username_1”的聯(lián)合索引，再次 執(zhí)行剛才的聯(lián)合查詢，就不會(huì)提示出錯(cuò)了。
通過建立該索引，數(shù)據(jù)庫(kù)中大致會(huì)按照如下方式來保存該索引：
...
[26,
"user1"
] -> 0x99887766
[26,
"user2"
] -> 0x99887722
[26,
"user5"
] -> 0x73234234
...
[30,
"user3"
] -> 0x37234234
[30,
"user9"
] -> 0x33231289
...
可以看到，索引中第一個(gè)字段“age”按照升序排列進(jìn)行排序，第二個(gè)字段 “username”也在第一個(gè)字段的范圍內(nèi)按照升序排列。
在ensureIndex函數(shù)中，建立索引時(shí)，通過將字段索引置為1，可以將索引標(biāo)識(shí)為 升序排列，如果索引置為-1，則將按照降序排列，如：
> db.users.ensureIndex({
"age"
: -1,
"username"
: 1})
這樣建立的索引“age”字段就將按照降序排列了。
MongoDB如何使用聯(lián)合索引進(jìn)行查詢，主要是看用戶如何執(zhí)行查詢語(yǔ)句，主要有 以下幾種情況：
> db.users.find({
"age"
: 26}).sort({
"username"
: -1})
這種情況下，由于查詢條件指定了“age”的大小，MongoDB可以使用剛才創(chuàng)建的聯(lián) 合索引直接找到“age”為26的所有項(xiàng)：
...
[26,
"user1"
] -> 0x99887766
[26,
"user2"
] -> 0x99887722
[26,
"user5"
] -> 0x73234234
...
并且由于username也是已經(jīng)排序了的，因此這個(gè)查詢可以很快完成。這里需要注 意的是，不管創(chuàng)建“username”索引的時(shí)候是使用的升序還是降序，MongoDB可以 直接找到最開始或者最后一項(xiàng)，直接進(jìn)行數(shù)據(jù)的遍歷，因此這個(gè)地方創(chuàng)建索引不 會(huì)對(duì)查詢?cè)斐捎绊憽?
> db.users.find({
"age"
: {
"$gte"
: 18,
"lte"
: 30}})
這種情況下，MongoDB仍然能夠迅速通過聯(lián)合索引查找到“age”字段在18到30范圍 內(nèi)的所有數(shù)據(jù)。
最后一種情況較為復(fù)雜：
> db.users.find({
"age"
: {
"$gte"
: 18,
"lte"
: 30}}).sort({
"username"
: -1})
這種情況下，MongoDB首先通過索引查找到“age”范圍在18到30之間的所有數(shù)據(jù)， 由于在這個(gè)范圍的數(shù)據(jù)集合中，“username”是未排序的，因此，MongoDB會(huì)在內(nèi) 存中對(duì)“username”進(jìn)行排序，然后將結(jié)果輸出，如果這個(gè)區(qū)間中的數(shù)據(jù)量很大的 話，仍然會(huì)出現(xiàn)前面看到的那種一場(chǎng)情況，由于有太多數(shù)據(jù)需要進(jìn)行排序操作， 導(dǎo)致程序報(bào)錯(cuò)：
error: {
"$err"
:
"too much data for sort() with no index. add an index or specify a smaller limit"
,
"code"
: 10128
}
這種情況下，可以通過建立一個(gè){"username" : 1, "age" : 1}這樣的反向的索 引來幫助進(jìn)行排序，這個(gè)索引建立后，索引大致如下所示：
...
[
"user0"
, 69]
[
"user1"
, 50]
[
"user10"
, 80]
[
"user100"
, 48]
[
"user1000"
, 111]
[
"user10000"
, 98]
[
"user100000"
, 21] -> 0x73f0b48d
[
"user100001"
, 60]
[
"user100002"
, 82]
[
"user100003"
, 27] -> 0x0078f55f
[
"user100004"
, 22] -> 0x5f0d3088
[
"user100005"
, 95]
...
這樣，MongoDB可以通過遍歷一次這個(gè)索引列表來進(jìn)行排序操作。這樣也避免了 在內(nèi)存中進(jìn)行大數(shù)據(jù)的排序操作。
對(duì)剛才的查詢執(zhí)行查詢計(jì)劃可以看到：
> db.users.find({
"age"
: {
"$gte"
: 21,
"$lte"
: 30}}).sort({
"username"
: 1}).explain()
{
"cursor"
:
"BtreeCursor username_1"
,
"isMultiKey"
:
false
,
"n"
: 83417,
"nscannedObjects"
: 1000000,
"nscanned"
: 1000000,
"nscannedObjectsAllPlans"
: 1002214,
"nscannedAllPlans"
: 1002214,
"scanAndOrder"
:
false
,
"indexOnly"
:
false
,
"nYields"
: 1,
"nChunkSkips"
: 0,
"millis"
: 1923,
"indexBounds"
: {
"username"
: [
[
{
"$minElement"
: 1
},
{
"$maxElement"
: 1
}
]
]
},
"server"
:
"WallE.local:27017"
}
使用hint函數(shù)，使用反向索引之后的結(jié)果如下：
> db.users.find({
"age"
: {
"$gte"
: 21,
"$lte"
: 30}}).sort({
"username"
: 1}).hint({
"username"
: 1,
"age"
: 1}).explain()
{
"cursor"
:
"BtreeCursor username_1_age_1"
,
"isMultiKey"
:
false
,
"n"
: 83417,
"nscannedObjects"
: 83417,
"nscanned"
: 984275,
"nscannedObjectsAllPlans"
: 83417,
"nscannedAllPlans"
: 984275,
"scanAndOrder"
:
false
,
"indexOnly"
:
false
,
"nYields"
: 2,
"nChunkSkips"
: 0,
"millis"
: 3064,
"indexBounds"
: {
"username"
: [
[
{
"$minElement"
: 1
},
{
"$maxElement"
: 1
}
]
],
"age"
: [
[
21,
30
]
]
},
"server"
:
"WallE.local:27017"
}
可以看到，第二次執(zhí)行的時(shí)間似乎還要長(zhǎng)一些。因此上面介紹的理論并不一定有 效，很多時(shí)候，為了提高數(shù)據(jù)庫(kù)的查詢效率，最好對(duì)所有查詢語(yǔ)句執(zhí)行查詢計(jì)劃， 查看執(zhí)行差異，從而進(jìn)行優(yōu)化。
通過上面的例子可以看到在使用聯(lián)合索引的時(shí)候，進(jìn)行查詢操作時(shí)，排在前面的 字段如果按照聯(lián)合索引的字段進(jìn)行查詢，都能夠利用到聯(lián)合索引的優(yōu)點(diǎn)。
例如，執(zhí)行如下查詢時(shí)，“age”字段是{"age" : 1, "username" : 1}的第一個(gè)字 段，這個(gè)時(shí)候就可以使用到這個(gè)聯(lián)合索引進(jìn)行查詢。
> db.users.find({
"age"
: 99})
例如查詢：
> db.users.find({
"a"
: 10,
"b"
: 20,
"c"
: 30})
就可以使用索引：{"a" : 1, "b" : 1, "c" : 1, "d" : 1}，只要是按照順序的 查詢都可以利用到索引來進(jìn)行查詢，當(dāng)然，如果順序不一致，就無(wú)法使用到索引 了，例如：
> db.users.find({
"c"
: 20,
"a"
: 10})
就無(wú)法使用{"a" : 1, "b" : 1, "c" : 1, "d" : 1}索引帶來的好處了。
同關(guān)系型數(shù)據(jù)庫(kù)一致，在MongoDB執(zhí)行查詢操作時(shí)，把最容易進(jìn)行范圍限定的條 件放到最前面，是最有利于查詢操作的，排在前面的條件能夠篩選的出來的結(jié)果 越少，后續(xù)的查詢效率也就越高。
在MongoDB中，對(duì)查詢優(yōu)化采用這樣一種方式，當(dāng)查詢條件與索引字段完全一致 時(shí)（如查詢“i”的字段，同時(shí)也存在一個(gè)索引為“i”的字段），則MongoDB會(huì)直接 使用這個(gè)索引進(jìn)行查詢。反之，如果有多個(gè)索引可能作用于此次查詢，則 MongoDB會(huì)采用不同的索引同時(shí)并行執(zhí)行多個(gè)查詢操作，最先返回100個(gè)數(shù)據(jù)的查 詢將會(huì)繼續(xù)進(jìn)行查詢，剩余的查詢操作將會(huì)被終止。MongoDB會(huì)將此次查詢進(jìn)行 緩存，下次查詢會(huì)繼續(xù)使用，直到對(duì)該數(shù)據(jù)集進(jìn)行了一定修改后，再次采用這種 方式進(jìn)行更新。在執(zhí)行explain()函數(shù)后輸出字段中的“allPlans”就表示，所有 嘗試進(jìn)行的查詢操作次數(shù)。
3 索引類型
在MongoDB中，也可以建立唯一索引：
> db.users.ensureIndex({
"username"
: 1}, {
"unique"
:
true
})
建立了唯一索引后，如果插入相同名稱的數(shù)據(jù)，系統(tǒng)就會(huì)報(bào)錯(cuò)：
> db.users.insert({
"username"
:
"user1"
})
E11000 duplicate key error index: test.users.$username_1 dup key: { :
"user1"
}
同樣的，聯(lián)合索引也可以建立唯一索引：
> db.users.ensureIndex({
"age"
: 1,
"username"
: 1}, {
"unique"
:
true
})
創(chuàng)建成功后，如果插入相同的數(shù)據(jù)內(nèi)容同樣會(huì)報(bào)錯(cuò)。
如果數(shù)據(jù)庫(kù)中已經(jīng)包含了重復(fù)數(shù)據(jù)，可以通過創(chuàng)建唯一索引的方式來進(jìn)行刪除。 但是注意，這種方式非常危險(xiǎn)，如果不是確定數(shù)據(jù)無(wú)效，不能這樣操作，因?yàn)椋?MongoDB只會(huì)保留遇到的第一個(gè)不同的數(shù)據(jù)項(xiàng)，后續(xù)重復(fù)數(shù)據(jù)都將被刪除：
> db.users.ensureIndex({
"age"
: 1,
"username"
: 1}, {
"unique"
:
true
,
"dropDups"
:
true
})
某些時(shí)候，我們希望對(duì)數(shù)據(jù)庫(kù)中某個(gè)字段建立唯一索引，但是又不一定是每條數(shù) 據(jù)都包含這個(gè)字段，這個(gè)時(shí)候，可以使用sparse索引來解決這個(gè)問題：
> db.users.ensureIndex({
"email"
: 1}, {
"unique"
:
true
,
"sparse"
: 1})
如果存在如下數(shù)據(jù)：
> db.foo.find()
{
"_id"
: 0 }
{
"_id"
: 1,
"x"
: 1 }
{
"_id"
: 2,
"x"
: 2 }
{
"_id"
: 3,
"x"
: 3 }
當(dāng)沒有建立索引的情況下，執(zhí)行如下操作會(huì)返回:
> db.foo.find({
"x"
: {
"$ne"
: 2}})
{
"_id"
: 0 }
{
"_id"
: 1,
"x"
: 1 }
{
"_id"
: 3,
"x"
: 3 }
如果建立了sparse索引，則MongoDB就不會(huì)返回第一條數(shù)據(jù)，而是返回所有包含 “x”字段的數(shù)據(jù)：
> db.foo.find({
"x"
: {
"$ne"
: 2}})
{
"_id"
: 0 }
{
"_id"
: 1,
"x"
: 1 }
{
"_id"
: 3,
"x"
: 3 }
4 索引管理
通過執(zhí)行g(shù)etIndexes()函數(shù)，可以獲得當(dāng)前數(shù)據(jù)集中所有的索引：
> db.users.getIndexes()
[
{
"v"
: 1,
"key"
: {
"_id"
: 1
},
"ns"
:
"test.users"
,
"name"
:
"_id_"
},
{
"v"
: 1,
"key"
: {
"age"
: 1,
"username"
: 1
},
"ns"
:
"test.users"
,
"name"
:
"age_1_username_1"
},
{
"v"
: 1,
"key"
: {
"username"
: 1,
"age"
: 1
},
"ns"
:
"test.users"
,
"name"
:
"username_1_age_1"
},
{
"v"
: 1,
"key"
: {
"username"
: 1
},
"unique"
:
true
,
"ns"
:
"test.users"
,
"name"
:
"username_1"
}
]
其中的“name”字段可以用于對(duì)索引的刪除操作：
> db.users.dropIndex(
"username_1_age_1"
)
就將刪除{"username" : 1, "age" : 1}這個(gè)索引。
更多文章、技術(shù)交流、商務(wù)合作、聯(lián)系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號(hào)聯(lián)系： 360901061
您的支持是博主寫作最大的動(dòng)力，如果您喜歡我的文章，感覺我的文章對(duì)您有幫助，請(qǐng)用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點(diǎn)擊下面給點(diǎn)支持吧，站長(zhǎng)非常感激您！手機(jī)微信長(zhǎng)按不能支付解決辦法：請(qǐng)將微信支付二維碼保存到相冊(cè)，切換到微信，然后點(diǎn)擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對(duì)您有幫助就好】元
