在九月初的時候，RMongoDB正式發布了修訂版本，這也就意味著，從事數值計算的語言也可以于Nosql產品相接軌了，但是鑒于我身邊并沒有公司真的在使用R和MongoDB的結合，所以在效率問題上，我們也不敢掉以輕心，所以就做了一個這樣的測試。

測試環境是8核，64位機。 用于測試的庫是一個未經Sharding，大概30G左右的Collection。用于存儲用戶的喜好信息，標簽信息等數據。

library(rmongodb)   
 
mongo <- mongo.create()  
 
if(mongo.is.connected(mongo))  
{  
    ns <- 'rivendell.user' 
    print('查詢一個沒有索引的字段，查詢一條')  
    print(system.time(p <- mongo.find.one(mongo,ns,list(Friend=600))))  
    print('查詢一個沒有索引的字段，多條,without buffer')  
    print(system.time(p <- mongo.find(mongo,ns,list(Friend=600))))  
    print('看看是否有緩存策略')  
    print(system.time(p <- mongo.find(mongo,ns,list(Friend=600))))  
 
    print('查詢一個沒有索引的字段，多條,has buffer')  
    buf <- mongo.bson.buffer.create()  
    mongo.bson.buffer.append(buf,'Friend',600L)  
    query <- mongo.bson.from.buffer(buf)  
    print(system.time(p <- mongo.find(mongo,ns,query)))  
    print('看看是否有緩存策略')  
    buf <- mongo.bson.buffer.create()  
    mongo.bson.buffer.append(buf,'Friend',600L)  
    query <- mongo.bson.from.buffer(buf)  
    print(system.time(p <- mongo.find(mongo,ns,query)))  
 
    print('大于的查詢，查詢一條記錄')  
    print(system.time(p <- mongo.find.one(mongo,ns,list(Friend=list('$gt'=600L)))))  
    print('大于的記錄，查詢多條記錄')  
    print(system.time(cursor <- mongo.find(mongo,ns,list(Friend=list('$gt'=600L)))))  
    mongo.cursor.destroy(cursor)  
 
    print('查詢一條有索引的記錄')  
    print(system.time(p <- mongo.find.one(mongo,ns,list('_id'=3831809L))))  
    print('查詢索引的記錄')  
    print(system.time(p <- mongo.find(mongo,ns,list('_id'=3831809L))))  
 
    print('插入一條記錄')  
    buf <- mongo.bson.buffer.create()  
    mongo.bson.buffer.append(buf,'name',"huangxin")  
    mongo.bson.buffer.append(buf,'age',22L)  
    p <- mongo.bson.from.buffer(buf)  
    print(system.time(mongo.insert(mongo,ns,p)))  
 
    print('找到剛剛插入的記錄')  
    print(system.time(p <- mongo.find.one(mongo,ns,list('name'='huangxin'))))  
    if(!is.null(p))  
    {  
        print('success')  
    }  
 
    print('批量插入')  
 
    buf <- mongo.bson.buffer.create()  
    mongo.bson.buffer.append(buf,'name','huangxin')  
    mongo.bson.buffer.append(buf,'age',22L)  
    p1 <- mongo.bson.from.buffer(buf)  
 
    buf <- mongo.bson.buffer.create()  
    mongo.bson.buffer.append(buf,'name','huangxin')  
    mongo.bson.buffer.append(buf,'age',22L)  
    p2 <- mongo.bson.from.buffer(buf)  
 
    buf <- mongo.bson.buffer.create()  
    mongo.bson.buffer.append(buf,'name','huangxin')  
    mongo.bson.buffer.append(buf,'age',22L)  
    p3 <- mongo.bson.from.buffer(buf)  
 
    print(system.time(mongo.insert.batch(mongo,ns,list(p1,p2,p3))))  
 
    print('找到剛剛批量插入的記錄')  
    print(system.time(cursor <- mongo.find(mongo,ns,list('name'='huangxin'))))  
 
    i <- 0  
    while(mongo.cursor.next(cursor))  
    {  
        i <- i + 1  
    }  
    print(i)  
 
    print('批量更新')  
    print(system.time(mongo.update(mongo,ns,list(name='huangxin'),list('name'= 'kym'))))  
 
    print('查看更新是否成功')  
    print(system.time(p <- mongo.find.one(mongo,ns,list('name'='kym'))))  
    if(!is.null(p))  
    {  
        print('success')  
    }  
 
    print('批量刪除')  
    print(system.time(mongo.remove(mongo,ns,list(name='kym'))))  
}  
 
    print(system.time(p <- mongo.find.one(mongo,ns,list('name'='kym'))))  
    if(!is.null(p))  
    {  
        print('success')  
    }  

[1] "查詢一個沒有索引的字段，查詢一條" 
user system elapsed  
0.000 0.000 0.115  
[1] "查詢一個沒有索引的字段，多條,without buffer" 
user system elapsed  
0.000 0.000 32.513  
[1] "看看是否有緩存策略" 
user system elapsed  
0.000 0.000 32.528  
[1] "查詢一個沒有索引的字段，多條,has buffer" 
user system elapsed  
0.000 0.000 32.685  
[1] "看看是否有緩存策略" 
user system elapsed  
0.000 0.000 33.172  
[1] "大于的查詢，查詢一條記錄" 
user system elapsed  
0.000 0.000 0.001  
[1] "大于的記錄，查詢多條記錄" 
user system elapsed  
0.000 0.000 0.014  
[1] "查詢一條有索引的記錄" 
user system elapsed  
0 0 0  
[1] "查詢索引的記錄" 
user system elapsed  
0 0 0  
[1] "插入一條記錄" 
user system elapsed  
0 0 0  
[1] "找到剛剛插入的記錄" 
user system elapsed  
0.00 0.00 35.42  
[1] "success" 
[1] "批量插入" 
user system elapsed  
0 0 0  
[1] "找到剛剛批量插入的記錄" 
user system elapsed  
0.004 0.000 35.934  
[1] 7  
[1] "批量更新" 
user system elapsed  
0.000 0.004 0.000  
[1] "查看更新是否成功" 
user system elapsed  
0.000 0.000 67.773  
[1] "success" 
[1] "批量刪除" 
user system elapsed  
0 0 0  
user system elapsed  
0.000 0.000 91.396 

之前我一直不太理解的就是為什么大于和等于，差距會差這么多。后來當我在用Python去做同樣的測試的時候發現，Python兩者的效率其實是相同的，所以這就證明了這個不是MongoDB的問題，而我不相信在數據庫層面，一個語言的Driver會有這么大的差別。

后來我發現了Python和R的關于MongoDB Driver的一個區別。首先，Python find的時候，不是將查詢到的數據集整體拉回，而是返回一個cursor，也就是說，他在執行find命令的時候并不消耗時間，而如果加上while cursor.next()的時候，才會真正地去執行這個查詢。

但是R不一樣，R會首先考慮數據集的大小（或者其他情況），然后視情況而定地返回cursor還是將整個數據集整體拉回。如果我們將之前的while mongo.cursor.next(cursor)也算在計算時間的時候，那么我們就會發現，其實大于和等于的操作，效率相差并不明顯了.......

在實際操作中，批量插入是一個非常常見的應用場景，但是對于R或者Matlab語言來說，循環的效率一直是硬傷，所以接下來，我會嘗試著用apply系列來解決R語言的循環問題，如果實際操作發現可行，那么接下來使用mutilab等R的并行計算庫來充分發揮多核的效率也值得嘗試了！

原文鏈接：http://www.cnblogs.com/kym/archive/2011/09/26/2191501.html

【編輯推薦】

1. MongoDB之父：MongoDB勝過BigTable
2. 主流NoSQL數據庫全方位評測之MongoDB
3. 教你如何利用MySQL學習MongoDB
4. 在Windows環境下MongoDB搭建和簡單操作
5. 教你五步優化你的MongoDB