mongo學習使用記錄1

1 mongo的安裝

 

1.添加MongoDB安裝源

 

 

1.添加MongoDB安裝源
vim /etc/yum.repos.d/mongodb-enterprise.repo

將下列配置項寫入文件

 

[mongodb-enterprise]

 

name=MongoDB Enterprise Repository

 

baseurl=https://repo.mongodb.com/yum/redhat/$releasever/mongodb-enterprise/stable/$basearch/

 

gpgcheck=0

 

enabled=1

 

 

2.用yum安裝MongoDB

yum install mongodb-enterprise

3.設置MongoDB進程開機啓動

chkconfig mongod on #不建議使用這種方式
或者
echo "mongod -f /etc/mongod.conf --rest" >>/etc/rc.local #建議使用這種開機啓動方式

 

詳細信息介紹：
1.安裝mongodb-enterprise，會安裝如下幾個包
mongodb-enterprise-server,包括Mongod進程，配置文件和初始化腳本；
mongodb-enterprise-mongos，包括mongos進程；
mongodb-enterprise-shell，包括mongo shell進程；
mongodb-enterprise-tools，包括mongoimport bsondump, mongodump,mongoexport, mongofiles, mongoimport, mongooplog, mongoperf, mongorestore, mongostat, 和mongotop工具；

 

2.yun MongoDB後配置文件爲/etc/mongodb,初始化腳本爲/etc/rc.d/init.d/mongod;

3.安裝其餘版本的MongoDB，例如安裝2.6.1版本
yum install mongodb-enterprise-2.6.1

 

二、 windows安裝

 

安裝Mongo數據庫：

 

第一步：下載安裝包：若是是win系統，注意是64位仍是32位版本的，請選擇正確的版本。http://www.mongodb.org/downloads 

 

第二步：新建目錄「D:\MongoDB」，解壓下載到的安裝包，找到bin目錄下面所有.exe文件，拷貝到剛建立的目錄下。

 

第三步：在「D:\MongoDB」目錄下新建「data」文件夾，它將會做爲數據存放的根文件夾。

 

配置Mongo服務端：

 

　打開CMD窗口，按照以下方式輸入命令：
　　> cd D:\MongoDB
　　> mongod --dbpath D:\MongoDB\data

 

　　配置成功後會看到以下畫面：

 

 

在瀏覽器輸入：http://localhost:27017/，能夠看到以下提示：
You are trying to access MongoDB on the native driver port. For http diagnostic access, add 1000 to the port number

如此，MongoDB數據庫服務已經成功啓動了。

下表爲mongodb啓動的參數說明：

參數	描述
--bind_ip	綁定服務IP，若綁定127.0.0.1，則只能本機訪問，不指定默認本地全部IP
--logpath	定MongoDB日誌文件，注意是指定文件不是目錄
--logappend	使用追加的方式寫日誌
--dbpath	指定數據庫路徑
--port	指定服務端口號，默認端口27017
--serviceName	指定服務名稱
--serviceDisplayNam	指定服務名稱，有多個mongodb服務時執行。
--install	指定做爲一個Windows服務安裝。

 

啓動：

mongod -dbpath=/usr/local/mongodb/data --fork --port 27017 --logpath=/usr/local/mongodb/log/work.log --logappend --auth  

mongod --dbpathD:\workspace\mongodb\data  

 

註冊爲windows系統服務：

mongod --logpath "D:\workspace\mongodb\log\mongodb.log" --logappend --dbpath "D:\workspace\mongodb\data" --directoryperdb --port 27017 --serviceName "mongodbService" --serviceDisplayName "mongodbService" --install 

 

MongoDB基本知識

 

1.MongoDB的數據基本稱爲文檔，相似關係數據庫的中的行；
2.相似，集合（Collection）是動態模式（dynamic schame）的表；
3.MongoDB的實例能夠有多個相互獨立的數據庫，沒有數據庫中包含多個集合；
4.每一個文檔都有一個鍵，這個鍵在所在的集合中是惟一的；
5.MongoDB自帶一個JavaScript Shell，用來管理MongoDB實例和數據操做；

（1）.文檔和鍵
文檔數據表達相似哈希或者字典，例如：
｛」geeting」:」hello world!」,」foo」:3｝
或者
｛」geeting」:」hello world!」｝
｛」foo」:3｝
geeting和foo是鍵，」hello world」和3是值；

MongoDB區分大小，類型和順序，例如
｛」foo」:3｝
｛「FOO」:3｝
｛」foo」:」3「｝
｛」foo」:3｝
｛」geeting」:」hello world!」,」foo」:3｝
｛」foo」:3，「geeting」:」hello world!」｝
這是個文檔是不一樣的；

集合中的鍵不能重複，例如
｛」foo」:」hello world!」,」foo」:3｝
這個文檔是非法的；

（2）.動態模式（dynamic schame）
集合是動態模式的，意思是集合中的文檔能夠是各種各樣的，例如
｛」geeting」:」hello world!」｝
｛」foo」:3｝
固然也能夠將同一類格式的文檔放進同一個集合，易建立索引和加快搜索，可是不強制這樣作；

（3）.集合
集合中能夠有子集合，用點號來分隔，例如
集合blog有子集合posts和子集合authors,其分別表示爲
blog.posts
blog.authors

（4）.MongoDB數據庫
MongoDB數據庫是有多個集合組成，每一個數據庫都是一個單獨的文件；MongoDB有保留的數據庫名，例如
admin, 這是身份驗證數據庫，將用戶添加到admin數據庫，這個用戶將自動得到全部的數據庫的權限；另外，一些特殊的命令也只能從admin數據庫運行，如列出數據庫和關閉服務器；
local，全部的本地集合均可以在存儲在這個數據庫中。
config，MongoDB數據庫用於分片設置，分片信息會存儲在config數據庫中；

 

mongo的簡單使用

SQL術語/概念	MongoDB術語/概念	解釋/說明
database	database	數據庫
table	collection	數據庫表/集合
row	document	數據記錄行/文檔
column	field	數據字段/域
index	index	索引
primary key	primary key	主鍵,MongoDB自動將_id字段設置爲主鍵

 

use DATABASE_NAME 若是數據庫不存在，則建立數據庫，不然切換到指定數據庫。
show dbs
db.dropDatabase()
db.cl.drop()
db.cl.insert({})
db.cl.save({})若指定_id更新 不然保存
db.cl.find().pretty()
db.cl.findOne()

db.getCollection('ideas').find({"_id":ObjectId("562dbecc87b15026cadb60d6")}) 按照id查詢

db.collection.update(
<query>,
<update>,
{
upsert: <boolean>,
multi: <boolean>,
writeConcern: <document>
} 
)
參數說明：
query : update的查詢條件，相似sql update查詢內where後面的。
update : update的對象和一些更新的操做符（如$,$inc...）等，也能夠理解爲sql update查詢內set後面的
upsert : 可選，這個參數的意思是，若是不存在update的記錄，是否插入objNew,true爲插入，默認是false，不插入。
multi : 可選，mongodb 默認是false,只更新找到的第一條記錄，若是這個參數爲true,就把按條件查出來多條記錄所有更新。
writeConcern :可選，拋出異常的級別

db.COLLECTION_NAME.update({},{},true|false,true|false);
第一個參數是查詢選擇器，與findOne的參數同樣，至關於sql的where子句
第二個參數是更新操做文件，由各類更新操做符和更新值構成，
第三個參數是upsert。若是是true，表示若是沒有符合查詢選擇器的文檔，mongo將會綜合第一第二個參數向集合插入一個新的文檔。
第四個參數是multi。true:更新匹配到的全部文檔，false：更新匹配到的第一個文檔，默認值
第三第四個參數也能夠合併成一個：
db.COLLECTION_NAME.update({},{},{multi:true|false,upsert:true|false});

db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}})
db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}},{multi:true})
只更新第一條記錄：
db.col.update( { "count" : { $gt : 1 } } , { $set : { "test2" : "OK"} } );
所有更新：
db.col.update( { "count" : { $gt : 3 } } , { $set : { "test2" : "OK"} },false,true );
只添加第一條：
db.col.update( { "count" : { $gt : 4 } } , { $set : { "test5" : "OK"} },true,false );
所有添加加進去:
db.col.update( { "count" : { $gt : 5 } } , { $set : { "test5" : "OK"} },true,true );
所有更新：
db.col.update( { "count" : { $gt : 15 } } , { $inc : { "count" : 1} },false,true );
只更新第一條記錄：
db.col.update( { "count" : { $gt : 10 } } , { $inc : { "count" : 1} },false,false );

db.getCollection('ideas').update({"user_id":"290536", "status" : { "$in" : [ "originality"]}},{$set:{'view_at':NumberLong(0)}},{multi:true})
db.getCollection('cycle_pending_idea_reminder').find({"user_id":"290536"},{$set:{"isFinished":false}},{multi:true})
db.getCollection('idea_selection_reminder').update({"user_id":"290536"},{$set:{"isFinished":false}},{multi:true})

db.getCollection('ideas').update({"user_id":"290536", "status" : { "$in" : [ "originality"]}},{$set:{'view_at':NumberLong(0)}},{multi:true})
db.getCollection('idea_selection_reminder').update({"user_id":"290536"},{$set:{"isFinished":false}},{multi:true})
db.getCollection('cycle_pending_idea_reminder').update({"user_id":"290536"},{$set:{"is_finished":false}},{multi:true})

簡單介紹一下$addToSet
以這篇博文爲例，若是我要增長一個標籤能夠執行如下命令
use iteye
db.blog.update({title:'mongo簡介——$addToSet，update', author:'runfriends'},{$addToSet:{tags:'mongodb'}});
要增長多個就執行：
db.blog.update({title:'mongo簡介——$addToSet，update'},{$addToSet:{tags:{$each:['Mongo','MongoDB','MONGODB']}}});

擁有相似事務特性的更新與查詢操做——findAndModify.
它是原子性的，會返回符合查詢條件的更新後的文檔。
一次最多隻更新一個文檔，也就是條件query條件，且執行sort後的第一個文檔。
db.COLLECTION_NAME.findAndModify({query:{},
update:{},
remove:true|false,
new:true|false,
sort:{},
fields:{},
upsert:true|false});
query是查詢選擇器，與findOne的查詢選擇器相同
update是要更新的值，不能與remove同時出現
remove表示刪除符合query條件的文檔，不能與update同時出現
new爲true：返回個性後的文檔，false：返回個性前的，默認是false
sort：排序條件，與sort函數的參數一致。
fields:投影操做，與find*的第二個參數一致。
upsert:與update的upsert參數同樣。

不管是update的第二個參數，仍是findAndModify的update，在不指定更新操做符的狀況下，將會用指定的新值替換舊值。

db.collection.remove(
<query>,
{
justOne: <boolean>,
writeConcern: <document>
}
)
參數說明：
query :（可選）刪除的文檔的條件。
justOne : （可選）若是設爲 true 或 1，則只刪除一個文檔。
writeConcern :（可選）拋出異常的級別。

 

db.cl.find().pretty()
操做 格式 範例 RDBMS中的相似語句
等於 {<key>:<value>} db.col.find({"by":"菜鳥教程"}).pretty() where by = '菜鳥教程'
小於 {<key>:{$lt:<value>}} db.col.find({"likes":{$lt:50}}).pretty() where likes < 50
小於或等於 {<key>:{$lte:<value>}} db.col.find({"likes":{$lte:50}}).pretty() where likes <= 50
大於 {<key>:{$gt:<value>}} db.col.find({"likes":{$gt:50}}).pretty() where likes > 50
大於或等於 {<key>:{$gte:<value>}} db.col.find({"likes":{$gte:50}}).pretty() where likes >= 50
不等於 {<key>:{$ne:<value>}} db.col.find({"likes":{$ne:50}}).pretty() where likes != 50

{'$and':[{'tenant':?2}, {'reportTime':{'$gte':?0}}, {'reportTime':{'$lte':?1}}]}
{'tenant':?2,'reportTime':{'$gte':?0,'$lte':?1}}

$regex 模式匹配 (可認爲模糊查詢) 對於正則表達式中的元字符須要轉義 例如 \ . * | + $ [ ( {等。

$in
$inc

AND：
MongoDB 的 find() 方法能夠傳入多個鍵(key)，每一個鍵(key)以逗號隔開，及常規 SQL 的 AND 條件。
>db.col.find({key1:value1, key2:value2}).pretty()
db.col.find(
{
$and: [
{key1: value1}, {key2:value2}
]
}
).pretty()

OR：
db.col.find(
{
$or: [
{key1: value1}, {key2:value2}
]
}
).pretty()

db.col.find({"likes": {$gt:50}, $or: [{"by": "菜鳥教程"},{"title": "MongoDB 教程"}]}).pretty()
'where likes>50 AND (by = '菜鳥教程' OR title = 'MongoDB 教程')'

形如 a>1 and b>2 or c>3 and d>4 的邏輯查詢，若是使用mongodb查詢，應該寫爲：

db.example.find({
'$or':[
{'$and':[{'example.a':{'$gt':1}},{'example.b':{'$gt':2}}]},
{'$and':[{'example.c':{'$gt':3}},{'example.d':{'$gt':4}}]}
]
})

類型 $type
若是想獲取 "col" 集合中 title 爲 String 的數據，你可使用如下命令：
db.col.find({"title" : {$type : 2}})

類型 數字 備註
Double 1  
String 2  
Object 3  
Array 4  
Binary data 5  
Undefined 6 已廢棄。
Object id 7  
Boolean 8  
Date 9  
Null 10  
Regular Expression 11  
JavaScript 13  
Symbol 14  
JavaScript (with scope) 15  
32-bit integer 16  
Timestamp 17  
64-bit integer 18  
Min key 255 Query with -1.
Max key 127

limit:
db.col.find({},{"title":1,_id:0}).limit(2)顯示前2條
skip:
db.col.find({},{"title":1,_id:0}).limit(1).skip(1) 顯示第2條

 

sort:
sort()方法能夠經過參數指定排序的字段，並使用 1 和 -1 來指定排序的方式，其中 1 爲升序排列，而-1是用於降序排列。
db.COLLECTION_NAME.find().sort({KEY:1})

建立索引
db.col.ensureIndex({"title":1})

db.getCollection('zjy_t_user_records').ensureIndex({
"username":1,
"deleted":-1 
},{
"name":"_idx_un_d_",
"unique":true 
});

Parameter Type Description
background Boolean 建索引過程會阻塞其它數據庫操做，background可指定之後臺方式建立索引，即增長 "background" 可選參數。 "background" 默認值爲false。
unique Boolean 創建的索引是否惟一。指定爲true建立惟一索引。默認值爲false.
name string 索引的名稱。若是未指定，MongoDB的經過鏈接索引的字段名和排序順序生成一個索引名稱。
dropDups Boolean 在創建惟一索引時是否刪除重複記錄,指定 true 建立惟一索引。默認值爲 false.
sparse Boolean 對文檔中不存在的字段數據不啓用索引；這個參數須要特別注意，若是設置爲true的話，在索引字段中不會查詢出不包含對應字段的文檔.。默認值爲 false.
expireAfterSeconds integer 指定一個以秒爲單位的數值，完成 TTL設定，設定集合的生存時間。
v index version 索引的版本號。默認的索引版本取決於mongod建立索引時運行的版本。
weights document 索引權重值，數值在 1 到 99,999 之間，表示該索引相對於其餘索引字段的得分權重。
default_language string 對於文本索引，該參數決定了停用詞及詞幹和詞器的規則的列表。 默認爲英語
language_override string 對於文本索引，該參數指定了包含在文檔中的字段名，語言覆蓋默認的language，默認值爲

聚合：

db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
select by_user, count(*) from mycol group by by_user

表達式 描述 實例
$sum 計算總和。 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : "$likes"}}}])
$avg 計算平均值 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$avg : "$likes"}}}])
$min 獲取集合中全部文檔對應值得最小值。 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$min : "$likes"}}}])
$max 獲取集合中全部文檔對應值得最大值。 db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$max : "$likes"}}}])
$push 在結果文檔中插入值到一個數組中。 db.mycol.aggregate([{$group : {_id : "$by_user", url : {$push: "$url"}}}])
$addToSet在結果文檔中插入值到一個數組中，但不建立副本。 db.mycol.aggregate([{$group : {_id : "$by_user", url : {$addToSet : "$url"}}}])
$first 根據資源文檔的排序獲取第一個文檔數據。 db.mycol.aggregate([{$group : {_id : "$by_user", first_url : {$first : "$url"}}}])
$last 根據資源文檔的排序獲取最後一個文檔數據 db.mycol.aggregate([{$group : {_id : "$by_user", last_url : {$last : "$url"}}}])

管道：

$project：修改輸入文檔的結構。能夠用來重命名、增長或刪除域，也能夠用於建立計算結果以及嵌套文檔。
$match：用於過濾數據，只輸出符合條件的文檔。$match使用MongoDB的標準查詢操做。
$limit：用來限制MongoDB聚合管道返回的文檔數。
$skip：在聚合管道中跳過指定數量的文檔，並返回餘下的文檔。
$unwind：將文檔中的某一個數組類型字段拆分紅多條，每條包含數組中的一個值。
$group：將集合中的文檔分組，可用於統計結果。
$sort：將輸入文檔排序後輸出。
$geoNear：輸出接近某一地理位置的有序文檔。

$match實例
db.articles.aggregate( [
{ $match : { score : { $gt : 70, $lte : 90 } } },
{ $group: { _id: null, count: { $sum: 1 } } }
] );
$match用於獲取分數大於70小於或等於90記錄，而後將符合條件的記錄送到下一階段$group管道操做符進行處理。
$skip實例
db.article.aggregate({ $skip : 5 });
通過$skip管道操做符處理後，前五個文檔被"過濾"掉

 --------------------------------------------- --------------------------------------------- --------------------------------------------- --------------------------------------------- ---------------------------------------------

Mongodb基礎用法及查詢操做

插入多條測試數據
> for(i=1;i<=1000;i++){
... db.blog.insert({"title":i,"content":"mongodb測試文章。","name":"劉"+i});                                                      
... }

db.blog.list.find().limit(10).forEach(function(data){print("title:"+data.title);})   循環forEach 用法

 

db.blog.findOne();  取一條數據

db.blog.find();取多條數據
db.blog.remove(); 刪除數據集 
db.blog.drop();刪除表

刪除一個數據庫： 
1.use dbname 
2.db.dropDatabase()

======================================查詢操做=============================
db.blog.find() 至關於select * from blog 
db.blog.find({"age":27}) 至關於select * from blog where age='27'
db.blog.find({"age":27,"name":"xing"}) 至關於select * from blog where age='27' and name="xing"
db.blog.find({},{"name":1}) select name from blog ,若是name：0則是不顯示name字段
db.blog.find().limit(1) 至關於select * from blog limit 1

db.blog.find().sort({_id:-1}).limit(1)至關於select * from blog order by _id desc limit 1
db.blog.find().skip(10).limit(20) 至關於select * from blog limit 10,20
skip用的時候，必定要注意要是數量多的話skip就會變的很慢，全部的數據庫都存在此問題,能夠不用skip進行分頁，用最後一條記錄作爲條件
db.blog.find({"age":{"$gte":18,"$lte":30}})     select * from blog  where age>=27 and age<=50
$gt   >
$gte  >=
$lt   <
$lte  <=
$ne   !=
$in : in 
$nin: not in 
$all: all 
$not: 反匹配

查詢 creation_date ＞ '2010-01-01' and creation_date ＜= '2010-12-31' 的數據 
db.users.find({creation_date:{$gt:new Date(2010,0,1), $lte:new Date(2010,11,31)});

 

db.blog.find().sort({_id:-1})  至關於select * from blog  order by _id desc  按_id倒序取數據  1爲正序，多個條件用,號分開如{name:1,age:-1}
db.blog.find({"_id":{"$in",[12,3,100]}})  至關於select * from blog where _id in (12,3,100)
db.blog.find({"_id":{"$nin",[12,3,100]}})  至關於select * from blog where _id not in (12,3,100)
db.blog.find({"$or":[{"age":16},{"name":"xing"}]}) 至關於select * from blog where age = 16 or name = 'xing'
db.blog.find({"id_num":{"$mod":[5,1]}}) 取的是id_num mod 5 = 1 的字段，如id_num=1,6,11,16
db.blog.find({"id_num":{"$not":{"$mod":[5,1]}}}) 取的是id_num mod 5 != 1 的字段，如除了id_num=1,6,11,16等全部字段，多於正則一塊兒用

$exists判斷字段是否存在

db.blog.find({ a : { $exists : true }}); // 若是存在元素a,就返回
db.blog.find({ a : { $exists : false }}); // 若是不存在元素a，就返回

$type判斷字段類型 
查詢全部name字段是字符類型的 
db.users.find({name: {$type: 2}}); 
查詢全部age字段是整型的 
db.users.find({age: {$type: 16}}); 

db.blog.find({"z":null}) 返回沒有z字段的全部記錄
db.blog.find({"name":/^joe/i}) 查找name=joe的全部記錄，不區分大小寫

db.blog.distinct('content')  查指定的列，並去重

查詢數組
db.blog.find({"fruit":{"$all":["蘋果","桃子","梨"]}})   fruit中必需有數組中的每個才符合結果
db.blog.find({"fruit":{"$size":3}})  fruit數組長度爲3的符合結果
db.blog.find({"$push":{"fruit":"桔子"}})至關於db.blog.find({"$push":{"fruit":"桔子"},"$inc":{"size":1}})
$slice 能夠按偏移量返回記錄，針對數組。如{"$slice":10}返回前10條,{"$slice":{[23,10]}}從24條取10條
若是對象有一個元素是數組，那麼$elemMatch能夠匹配內數組內的元素

db.people.find({"name.first":"joe","name.last":"schmoe"}) 子查詢如：{"id":34,"name":{"first":"joe","last":"schmoe"}}

db.blog.find({"comments":{"$elemMatch":{"author":"joe","score":{"$gte":5}}}}) 查joe發表的5分以上的評論，注意comments爲二維數組
$where 在走投無路的時候能夠用，但它的效率是很低的。


遊標用法
cursor.hasNext()檢查是否有後續結果存在，而後用cursor.next()將其得到。
>while(cursor.hasNext()){
   var obj = cursor.next();
   //do same
}

 

 

http://www.mongodb.org/display/DOCS/Advanced+Queries#AdvancedQueries-ConditionalOperators%3A%3C%2C%3C%3D%2C%3E%2C%3E%3D 手冊

 

> use blog
> db.blog.insert({"title":"華夏之星的博客","content":"mongodb測試文章。"});
> db.blog.find();
{ "_id" : ObjectId("4e29fd262ed6910732fa61df"), "title" : "華夏之星的博客", "content" : "mongodb測試文章。" }
> db.blog.update({title:"華夏之星的博客"},{"author":"星星","content":"測試更新"});
> db.blog.find();
{ "_id" : ObjectId("4e29fd262ed6910732fa61df"), "author" : "星星", "content" : "測試更新" }

 

 

 db.blog.insert不帶括號則顯示源碼
db.blog.insert();插入
db.blog.update();更新

> db.blog.update({title:"華夏之星的博客"},{"author":"星星","content":"測試更新"});

update默認狀況下只能對符合條件的第一個文檔執行操做，要使全部的匹配的文檔都獲得更新，能夠設置第四個參數爲 true

> db.blog.update({title:"華夏之星的博客"},{"author":"星星","content":"測試更新"},false,true);

> db.runCommand({getLastError:1}) 能夠查看更新了幾條信息，n就是條數

 

 備份blog數據庫到/soft目錄
/usr/local/webserver/mongodb/bin/mongodump -d blog -o /soft

還原數據庫

/usr/local/webserver/mongodb/bin/mongorestore -d blog -c blog   /soft/blog/blog.bson

 

 

導出數據庫(備份出來的數據是二進制的，已經通過壓縮。)
/usr/local/webserver/mongodb/bin/mongodump -h 127.0.0.1 -port 27017 -d demo -o /tmp/demo
導入數據
/usr/local/webserver/mongodb/bin/mongorestore -h 127.0.0.1  -port 27017 --directoryperdb /tmp/demo

 

5) $all
$all和$in相似，可是他須要匹配條件內全部的值：
若有一個對象：

{ a: [ 1, 2, 3 ] }

下面這個條件是能夠匹配的：

db.things.find( { a: { $all: [ 2, 3 ] } } );

可是下面這個條件就不行了：

db.things.find( { a: { $all: [ 2, 3, 4 ] } } );

6) $size
$size是匹配數組內的元素數量的，若有一個對象：{a:["foo"]}，他只有一個元素：
下面的語句就能夠匹配：

db.things.find( { a : { $size: 1 } } );

官網上說不能用來匹配一個範圍內的元素，若是想找$size<5之類的，他們建議建立一個字段來保存元素的數量。

 

8) $type

$type 基於 bson type來匹配一個元素的類型，像是按照類型ID來匹配，不過我沒找到bson類型和id對照表。

db.things.find( { a : { $type : 2 } } ); // matches if a is a string
db.things.find( { a : { $type : 16 } } ); // matches if a is an int

9）正則表達式
mongo支持正則表達式，如：

db.customers.find( { name : /acme.*corp/i } ); // 後面的i的意思是區分大小寫

10) 查詢數據內的值
下面的查詢是查詢colors內red的記錄，若是colors元素是一個數據,數據庫將遍歷這個數組的元素來查詢。

db.things.find( { colors : "red" } );

11) $elemMatch
若是對象有一個元素是數組，那麼$elemMatch能夠匹配內數組內的元素：

> t.find( { x : { $elemMatch : { a : 1, b : { $gt : 1 } } } } ) 
{ "_id" : ObjectId("4b5783300334000000000aa9"), 
"x" : [ { "a" : 1, "b" : 3 }, 7, { "b" : 99 }, { "a" : 11 } ]
}

$elemMatch : { a : 1, b : { $gt : 1 } } 全部的條件都要匹配上才行。

注意，上面的語句和下面是不同的。

> t.find( { "x.a" : 1, "x.b" : { $gt : 1 } } )

$elemMatch是匹配{ "a" : 1, "b" : 3 }，然後面一句是匹配{ "b" : 99 }, { "a" : 11 } 
12) 查詢嵌入對象的值

db.postings.find( { "author.name" : "joe" } );

注意用法是author.name，用一個點就好了。更詳細的能夠看這個連接： dot notation

舉個例子：

> db.blog.save({ title : "My First Post", author: {name : "Jane", id : 1}})

若是咱們要查詢 authors name 是Jane的, 咱們能夠這樣：

> db.blog.findOne({"author.name" : "Jane"})