摘要：但有時(shí)我們希望返回與查詢條件相匹配的任意一個(gè)數(shù)組元素。首先，可以使用要求同時(shí)使用查詢條件中的兩個(gè)語(yǔ)句與一個(gè)數(shù)組元素進(jìn)行比較。

上一篇文章：MongoDB指南---7、find簡(jiǎn)介與查詢條件
下一篇文章：MongoDB指南---9、游標(biāo)與數(shù)據(jù)庫(kù)命令

如第2章所述，MongoDB的文檔可以使用多種類型的數(shù)據(jù)。其中有一些在查詢時(shí)會(huì)有特別的表現(xiàn)。

null類型的行為有點(diǎn)奇怪。它確實(shí)能匹配自身，所以要是有一個(gè)包含如下文檔的集合：

> db.c.find()
{ "_id" : ObjectId("4ba0f0dfd22aa494fd523621"), "y" : null }
{ "_id" : ObjectId("4ba0f0dfd22aa494fd523622"), "y" : 1 }
{ "_id" : ObjectId("4ba0f148d22aa494fd523623"), "y" : 2 }

就可以按照預(yù)期的方式查詢"y"鍵為null的文檔：

> db.c.find({"y" : null})
{ "_id" : ObjectId("4ba0f0dfd22aa494fd523621"), "y" : null }

但是，null不僅會(huì)匹配某個(gè)鍵的值為null的文檔，而且還會(huì)匹配不包含這個(gè)鍵的文檔。所以，這種匹配還會(huì)返回缺少這個(gè)鍵的所有文檔：

> db.c.find({"z" : null})
{ "_id" : ObjectId("4ba0f0dfd22aa494fd523621"), "y" : null }
{ "_id" : ObjectId("4ba0f0dfd22aa494fd523622"), "y" : 1 }
{ "_id" : ObjectId("4ba0f148d22aa494fd523623"), "y" : 2 }

如果僅想匹配鍵值為null的文檔，既要檢查該鍵的值是否為null，還要通過(guò)"$exists"條件判定鍵值已存在：

> db.c.find({"z" : {"$in" : [null], "$exists" : true}})

很遺憾，沒有"$eq"操作符，所以這條查詢語(yǔ)句看上去有些令人費(fèi)解，但是使用只有一個(gè)元素的"$in"操作符效果是一樣的。

正則表達(dá)式能夠靈活有效地匹配字符串。例如，想要查找所有名為Joe或者joe的用戶，就可以使用正則表達(dá)式執(zhí)行不區(qū)分大小寫的匹配：

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

系統(tǒng)可以接受正則表達(dá)式標(biāo)志（i），但不是一定要有。現(xiàn)在已經(jīng)匹配了各種大小寫組合形式的joe，如果還希望匹配如"joey"這樣的鍵，可以略微修改一下剛剛的正則表達(dá)式：

> db.users.find({"name" : /joey?/i})

MongoDB使用Perl兼容的正則表達(dá)式（PCRE）庫(kù)來(lái)匹配正則表達(dá)式，任何PCRE支持的正則表達(dá)式語(yǔ)法都能被MongoDB接受。建議在查詢中使用正則表達(dá)式前，先在JavaScript shell中檢查一下語(yǔ)法，確保匹配與設(shè)想的一致。
MongoDB可以為前綴型正則表達(dá)式（比如/^joey/）查詢創(chuàng)建索引，所以這種類型的查詢會(huì)非常高效。
正則表達(dá)式也可以匹配自身。雖然幾乎沒有人直接將正則表達(dá)式插入到數(shù)據(jù)庫(kù)中，但要是萬(wàn)一你這么做了，也可以匹配到自身：

> db.foo.insert({"bar" : /baz/})
> db.foo.find({"bar" : /baz/})
{
    "_id" : ObjectId("4b23c3ca7525f35f94b60a2d"),
    "bar" : /baz/
} 

查詢數(shù)組元素與查詢標(biāo)量值是一樣的。例如，有一個(gè)水果列表，如下所示：

> db.food.insert({"fruit" : ["apple", "banana", "peach"]})

下面的查詢：

> db.food.find({"fruit" : "banana"})

會(huì)成功匹配該文檔。這個(gè)查詢好比我們對(duì)一個(gè)這樣的（不合法）文檔進(jìn)行查詢：{"fruit" : "apple", "fruit" : "banana", "fruit" : "peach"}。

如果需要通過(guò)多個(gè)元素來(lái)匹配數(shù)組，就要用"$all"了。這樣就會(huì)匹配一組元素。例如，假設(shè)創(chuàng)建了一個(gè)包含3個(gè)元素的集合：

> db.food.insert({"_id" : 1, "fruit" : ["apple", "banana", "peach"]})
> db.food.insert({"_id" : 2, "fruit" : ["apple", "kumquat", "orange"]})
> db.food.insert({"_id" : 3, "fruit" : ["cherry", "banana", "apple"]})

要找到既有"apple"又有"banana"的文檔，可以使用"$all"來(lái)查詢：

> db.food.find({fruit : {$all : ["apple", "banana"]}})
    {"_id" : 1, "fruit" : ["apple", "banana", "peach"]}
    {"_id" : 3, "fruit" : ["cherry", "banana", "apple"]}

這里的順序無(wú)關(guān)緊要。注意，第二個(gè)結(jié)果中"banana"在"apple"之前。要是對(duì)只有一個(gè)元素的數(shù)組使用"$all"，就和不用"$all"一樣了。例如，{fruit : {$all : ["apple"]}和{fruit : "apple"}的查詢結(jié)果完全一樣。
也可以使用整個(gè)數(shù)組進(jìn)行精確匹配。但是，精確匹配對(duì)于缺少元素或者元素冗余的情況就不大靈了。例如，下面的方法會(huì)匹配之前的第一個(gè)文檔：

> db.food.find({"fruit" : ["apple", "banana", "peach"]})

但是下面這個(gè)就不會(huì)匹配：

> db.food.find({"fruit" : ["apple", "banana"]})

這個(gè)也不會(huì)匹配：

> db.food.find({"fruit" : ["banana", "apple", "peach"]})

要是想查詢數(shù)組特定位置的元素，需使用key.index語(yǔ)法指定下標(biāo)：

> db.food.find({"fruit.2" : "peach"})

數(shù)組下標(biāo)都是從0開始的，所以上面的表達(dá)式會(huì)用數(shù)組的第3個(gè)元素和"peach"進(jìn)行匹配。

"$size"對(duì)于查詢數(shù)組來(lái)說(shuō)也是非常有用的，顧名思義，可以用它查詢特定長(zhǎng)度的數(shù)組。例如：

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

得到一個(gè)長(zhǎng)度范圍內(nèi)的文檔是一種常見的查詢。"$size"并不能與其他查詢條件（比如"$gt"）組合使用，但是這種查詢可以通過(guò)在文檔中添加一個(gè)"size"鍵的方式來(lái)實(shí)現(xiàn)。這樣每一次向指定數(shù)組添加元素時(shí)，同時(shí)增加"size"的值。比如，原本這樣的更新：

> db.food.update(criteria, {"$push" : {"fruit" : "strawberry"}})

就要變成下面這樣：

> db.food.update(criteria,
... {"$push" : {"fruit" : "strawberry"}, "$inc" : {"size" : 1}})

自增操作的速度非常快，所以對(duì)性能的影響微乎其微。這樣存儲(chǔ)文檔后，就可以像下面這樣查詢了：

> db.food.find({"size" : {"$gt" : 3}})

很遺憾，這種技巧并不能與"$addToSet"操作符同時(shí)使用。

本章前面已經(jīng)提及，find的第二個(gè)參數(shù)是可選的，可以指定需要返回的鍵。這個(gè)特別的"$slice"操作符可以返回某個(gè)鍵匹配的數(shù)組元素的一個(gè)子集。
例如，假設(shè)現(xiàn)在有一個(gè)博客文章的文檔，我們希望返回前10條評(píng)論，可以這樣做：

> db.blog.posts.findOne(criteria, {"comments" : {"$slice" : 10}})

也可以返回后10條評(píng)論，只要在查詢條件中使用-10就可以了：

> db.blog.posts.findOne(criteria, {"comments" : {"$slice" : -10}})

"$slice"也可以指定偏移值以及希望返回的元素?cái)?shù)量，來(lái)返回元素集合中間位置的某些結(jié)果：

db.blog.posts.findOne(criteria, {"comments" : {"$slice" : [23, 10]}})
這個(gè)操作會(huì)跳過(guò)前23個(gè)元素，返回第24~33個(gè)元素。如果數(shù)組不夠33個(gè)元素，則返回第23個(gè)元素后面的所有元素。
除非特別聲明，否則使用"$slice"時(shí)將返回文檔中的所有鍵。別的鍵說(shuō)明符都是默認(rèn)不返回未提及的鍵，這點(diǎn)與"$slice"不太一樣。例如，有如下博客文章文檔：

{
    "_id" : ObjectId("4b2d75476cc613d5ee930164"),
    "title" : "A blog post",
    "content" : "...",
    "comments" : [
        {
            "name" : "joe",
            "email" : "joe@example.com",
            "content" : "nice post."
        },
        {
            "name" : "bob",
            "email" : "bob@example.com",
            "content" : "good post."
        }
    ]
}

用"$slice"來(lái)獲取最后一條評(píng)論，可以這樣：

> db.blog.posts.findOne(criteria, {"comments" : {"$slice" : -1}})
{
    "_id" : ObjectId("4b2d75476cc613d5ee930164"),
    "title" : "A blog post",
    "content" : "...",
    "comments" : [
        {
            "name" : "bob",
            "email" : "bob@example.com",
            "content" : "good post."
        }
    ]
}

"title"和"content"都返回了，即便是并沒有顯式地出現(xiàn)在鍵說(shuō)明符中。

如果知道元素的下標(biāo)，那么"$slice"非常有用。但有時(shí)我們希望返回與查詢條件相匹配的任意一個(gè)數(shù)組元素。可以使用$操作符得到一個(gè)匹配的元素。對(duì)于上面的博客文章示例，可以用如下的方式得到Bob的評(píng)論：

> db.blog.posts.find({"comments.name" : "bob"}, {"comments.$" : 1})
{
    "_id" : ObjectId("4b2d75476cc613d5ee930164"),
    "comments" : [
        {
            "name" : "bob",
            "email" : "bob@example.com",
            "content" : "good post."
        }
    ]
}

注意，這樣只會(huì)返回第一個(gè)匹配的文檔。如果Bob在這篇博客文章下寫過(guò)多條評(píng)論，只有"comments"數(shù)組中的第一條評(píng)論會(huì)被返回。

文檔中的標(biāo)量（非數(shù)組元素）必須與查詢條件中的每一條語(yǔ)句相匹配。例如，如果使用{"x" : {"$gt" : 10, "$lt" : 20}}進(jìn)行查詢，只會(huì)匹配"x"鍵的值大于等于10并且小于等于20的文檔。但是，假如某個(gè)文檔的"x"字段是一個(gè)數(shù)組，如果"x"鍵的某一個(gè)元素與查詢條件的任意一條語(yǔ)句相匹配（查詢條件中的每條語(yǔ)句可以匹配不同的數(shù)組元素），那么這個(gè)文檔也會(huì)被返回。
下面用一個(gè)例子來(lái)詳細(xì)說(shuō)明這種情況。假如有如下所示的文檔：

{"x" : 5}
{"x" : 15}
{"x" : 25}
{"x" : [5, 25]}

如果希望找到"x"鍵的值位于10和20之間的所有文檔，直接想到的查詢方式是使用db.test.find({"x" : {"$gt" : 10, "$lt" : 20}})，希望這個(gè)查詢的返回文檔是{"x" : 15}。但是，實(shí)際返回了兩個(gè)文檔：

> db.test.find({"x" : {"$gt" : 10, "$lt" : 20}})
{"x" : 15}
{"x" : [5, 25]}

5和25都不位于10和20之間，但是這個(gè)文檔也返回了，因?yàn)?5與查詢條件中的第一個(gè)語(yǔ)句（大于10）相匹配，5與查詢條件中的第二個(gè)語(yǔ)句（小于20）相匹配。
這使對(duì)數(shù)組使用范圍查詢沒有用：范圍會(huì)匹配任意多元素?cái)?shù)組。有幾種方式可以得到預(yù)期的行為。
首先，可以使用"$elemMatch"要求MongoDB同時(shí)使用查詢條件中的兩個(gè)語(yǔ)句與一個(gè)數(shù)組元素進(jìn)行比較。但是，這里有一個(gè)問題，"$elemMatch"不會(huì)匹配非數(shù)組元素：

> db.test.find({"x" : {"$elemMatch" : {"$gt" : 10, "$lt" : 20}})
> // 查不到任何結(jié)果

{"x" : 15}這個(gè)文檔與查詢條件不再匹配了，因?yàn)樗?x"字段是個(gè)數(shù)組。
如果當(dāng)前查詢的字段上創(chuàng)建過(guò)索引（第5章會(huì)講述索引相關(guān)內(nèi)容），可以使用min()和max()將查詢條件遍歷的索引范圍限制為"$gt"和"$lt"的值：

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

現(xiàn)在，這個(gè)查詢只會(huì)遍歷值位于10和20之間的索引，不再與5和25進(jìn)行比較。只有當(dāng)前查詢的字段上建立過(guò)索引時(shí)，才可以使用min()和max()，而且，必須為這個(gè)索引的所有字段指定min()和max()。
在可能包含數(shù)組的文檔上應(yīng)用范圍查詢時(shí)，使用min()和max()是非常好的：如果在整個(gè)索引范圍內(nèi)對(duì)數(shù)組使用"$gt"/"$lt"查詢，效率是非常低的。查詢條件會(huì)與所有值進(jìn)行比較，會(huì)查詢每一個(gè)索引，而不僅僅是指定索引范圍內(nèi)的值。

有兩種方法可以查詢內(nèi)嵌文檔：查詢整個(gè)文檔，或者只針對(duì)其鍵/值對(duì)進(jìn)行查詢。
查詢整個(gè)內(nèi)嵌文檔與普通查詢完全相同。例如，有如下文檔：

{
    "name" : {
        "first" : "Joe",
        "last" : "Schmoe"
     },
     "age" : 45
} 

要查尋姓名為Joe Schmoe的人可以這樣：

> db.people.find({"name" : {"first" : "Joe", "last" : "Schmoe"}})

但是，如果要查詢一個(gè)完整的子文檔，那么子文檔必須精確匹配。如果Joe決定添加一個(gè)代表中間名的鍵，這個(gè)查詢就不再可行了，因?yàn)椴樵儣l件不再與整個(gè)內(nèi)嵌文檔相匹配。而且這種查詢還是與順序相關(guān)的，{"last" : "Schmoe"，"first" : "Joe"}什么都匹配不到。
如果允許的話，通常只針對(duì)內(nèi)嵌文檔的特定鍵值進(jìn)行查詢，這是比較好的做法。這樣，即便數(shù)據(jù)模式改變，也不會(huì)導(dǎo)致所有查詢因?yàn)橐_匹配而一下子都掛掉。我們可以使用點(diǎn)表示法查詢內(nèi)嵌文檔的鍵：

> db.people.find({"name.first" : "Joe", "name.last" : "Schmoe"})

現(xiàn)在，如果Joe增加了更多的鍵，這個(gè)查詢依然會(huì)匹配他的姓和名。
這種點(diǎn)表示法是查詢文檔區(qū)別于其他文檔的主要特點(diǎn)。查詢文檔可以包含點(diǎn)來(lái)表達(dá)“進(jìn)入內(nèi)嵌文檔內(nèi)部”的意思。點(diǎn)表示法也是待插入的文檔不能包含“.”的原因。將URL作為鍵保存時(shí)經(jīng)常會(huì)遇到此類問題。一種解決方法就是在插入前或者提取后執(zhí)行一個(gè)全局替換，將“.”替換成一個(gè)URL中的非法字符。
當(dāng)文檔結(jié)構(gòu)變得更加復(fù)雜以后，內(nèi)嵌文檔的匹配需要些許技巧。例如，假設(shè)有博客文章若干，要找到由Joe發(fā)表的5分以上的評(píng)論。博客文章的結(jié)構(gòu)如下例所示：

> db.blog.find()
{
    "content" : "...",
    "comments" : [
        {
            "author" : "joe",
            "score" : 3,
            "comment" : "nice post"
        },
        {
            "author" : "mary",
            "score" : 6,
            "comment" : "terrible post"
        }
    ]
}

不能直接用db.blog.find({"comments" : {"author" : "joe"，"score" : {"$gte" : 5}}})來(lái)查尋。內(nèi)嵌文檔的匹配，必須要整個(gè)文檔完全匹配，而這個(gè)查詢不會(huì)匹配"comment"鍵。使用db.blog.find({"comments.author" : "joe"，"comments.score" : {"$gte" : 5}}也不行，因?yàn)榉蟖uthor條件的評(píng)論和符合score條件的評(píng)論可能不是同一條評(píng)論。也就是說(shuō)，會(huì)返回剛才顯示的那個(gè)文檔。因?yàn)?author" : "joe"在第一條評(píng)論中匹配了，"score" : 6在第二條評(píng)論中匹配了。
要正確地指定一組條件，而不必指定每個(gè)鍵，就需要使用"$elemMatch"。這種模糊的命名條件句能用來(lái)在查詢條件中部分指定匹配數(shù)組中的單個(gè)內(nèi)嵌文檔。所以正確的寫法應(yīng)該是下面這樣的：

> db.blog.find({"comments" : {"$elemMatch" : {"author" : "joe",
                                              "score" : {"$gte" : 5}}}})

"$elemMatch"將限定條件進(jìn)行分組，僅當(dāng)需要對(duì)一個(gè)內(nèi)嵌文檔的多個(gè)鍵操作時(shí)才會(huì)用到。

鍵/值對(duì)是一種表達(dá)能力非常好的查詢方式，但是依然有些需求它無(wú)法表達(dá)。其他方法都敗下陣時(shí)，就輪到"$where"子句登場(chǎng)了，用它可以在查詢中執(zhí)行任意的JavaScript。這樣就能在查詢中做（幾乎）任何事情。為安全起見，應(yīng)該嚴(yán)格限制或者消除"$where"語(yǔ)句的使用。應(yīng)該禁止終端用戶使用任意的"$where"語(yǔ)句。
"$where"語(yǔ)句最常見的應(yīng)用就是比較文檔中的兩個(gè)鍵的值是否相等。假如我們有如下文檔：

> db.foo.insert({"apple" : 1, "banana" : 6, "peach" : 3}) 
> db.foo.insert({"apple" : 8, "spinach" : 4, "watermelon" : 4})

我們希望返回兩個(gè)鍵具有相同值的文檔。第二個(gè)文檔中，"spinach"和"watermelon"的值相同，所以需要返回該文檔。MongoDB似乎從來(lái)沒有提供過(guò)一個(gè)$條件語(yǔ)句來(lái)做這種查詢，所以只能用"$where"子句借助JavaScript來(lái)完成了：

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

如果函數(shù)返回true，文檔就做為結(jié)果集的一部分返回；如果為false，就不返回。
不是非常必要時(shí)，一定要避免使用"$where"查詢，因?yàn)樗鼈冊(cè)谒俣壬弦瘸Ｒ?guī)查詢慢很多。每個(gè)文檔都要從BSON轉(zhuǎn)換成JavaScript對(duì)象，然后通過(guò)"$where"表達(dá)式來(lái)運(yùn)行。而且"$where"語(yǔ)句不能使用索引，所以只在走投無(wú)路時(shí)才考慮"$where"這種用法。先使用常規(guī)查詢進(jìn)行過(guò)濾，然后再使用"$where"語(yǔ)句，這樣組合使用可以降低性能損失。如果可能的話，使用"$where"語(yǔ)句前應(yīng)該先使用索引進(jìn)行過(guò)濾，"$where"只用于對(duì)結(jié)果進(jìn)行進(jìn)一步過(guò)濾。
進(jìn)行復(fù)雜查詢的另一種方法是使用聚合工具，第7章會(huì)詳細(xì)介紹。

在服務(wù)器上執(zhí)行JavaScript時(shí)必須注意安全性。如果使用不當(dāng)，服務(wù)器端JavaScript很容易受到注入攻擊，與關(guān)系型數(shù)據(jù)庫(kù)中的注入攻擊類似。不過(guò)，只要在接受輸入時(shí)遵循一些規(guī)則，就可以安全地使用JavaScript。也可以在運(yùn)行mongod時(shí)指定--noscripting選項(xiàng)，完全關(guān)閉JavaScript的執(zhí)行。
JavaScript的安全問題都與用戶在服務(wù)器上提供的程序相關(guān)。如果希望避免這些風(fēng)險(xiǎn)，那么就要確保不能直接將用戶輸入的內(nèi)容傳遞給mongod。例如，假如你希望打印一句“Hello, name!”，這里的name是由用戶提供的。使用如下所示的JavaScript函數(shù)是非常容易想到的：

> func = "function() { print("Hello, "+name+"!"); }" 

如果這里的name是一個(gè)用戶定義的變量，它可能會(huì)是""); db.dropDatabase();print(""這樣一個(gè)字符串，因此，上面的代碼會(huì)被轉(zhuǎn)換成如下代碼：

> func = "function() { print("Hello, "); db.dropDatabase(); print("!"); }"

如果執(zhí)行這段代碼，你的整個(gè)數(shù)據(jù)庫(kù)就會(huì)被刪除！
為了避免這種情況，應(yīng)該使用作用域來(lái)傳遞name的值。以Python為例：

func = pymongo.code.Code("function() { print("Hello, "+username+"!"); }",
            {"username": name})

現(xiàn)在，數(shù)據(jù)庫(kù)會(huì)輸出如下的內(nèi)容，不會(huì)有任何風(fēng)險(xiǎn)：

Hello, "); db.dropDatabase(); print("!

由于代碼實(shí)際上可能是字符串和作用域的混合體，所以大多數(shù)驅(qū)動(dòng)程序都有一種特殊類型，用于向數(shù)據(jù)庫(kù)傳遞代碼。作用域是用于表示變量名和值的映射的文檔。對(duì)于要被執(zhí)行的JavaScript函數(shù)來(lái)說(shuō)，這個(gè)映射就是一個(gè)局部作用域。因此，在上面的例子中，函數(shù)可以訪問username這個(gè)變量，這個(gè)變量的值就是用戶傳進(jìn)來(lái)的字符串。
shell中沒有包含作用域的代碼類型，所以作用域只能在字符串或者JavaScript函數(shù)中使用。

上一篇文章：MongoDB指南---7、find簡(jiǎn)介與查詢條件
下一篇文章：MongoDB指南---9、游標(biāo)與數(shù)據(jù)庫(kù)命令