在九月初的时候，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
.000 0.000 0.115
[1] “查询一个没有索引的字段，多条,without buffer”
user system elapsed
.000 0.000 32.513
[1] “看看是否有缓存计策”
user system elapsed
.000 0.000 32.528
[1] “查询一个没有索引的字段，多条,has buffer”
user system elapsed
.000 0.000 32.685
[1] “看看是否有缓存计策”
user system elapsed
.000 0.000 33.172
[1] “大于的查询，查询一笔记录”
user system elapsed
.000 0.000 0.001
[1] “大于的记录，查询多笔记录”
user system elapsed
.000 0.000 0.014
[1] “查询一条有索引的记录”
user system elapsed
0 0
[1] “查询索引的记录”
user system elapsed
0 0
[1] “插入一笔记录”
user system elapsed
0 0
[1] “找到方才插入的记录”
user system elapsed
.00 0.00 35.42
[1] “success”
[1] “批量插入”
user system elapsed
0 0
[1] “找到方才批量插入的记录”
user system elapsed
.004 0.000 35.934
[1] 7
[1] “批量更新”
user system elapsed
.000 0.004 0.000
[1] “查察更新是否乐成”
user system elapsed
.000 0.000 67.773
[1] “success”
[1] “批量删除”
user system elapsed
0 0
user system elapsed
.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的并行计较库来充实发挥多核的效率也值得实验了！
