R对MongoDB的性能测试——RMongo
本文内容纲要：
在九月初的时候，RMongoDB正式发布了修订版本，这也就意味着，从事数值计算的语言也可以于Nosql产品相接轨了，但是鉴于我身边并没有公司真的在使用R和MongoDB的结合，所以在效率问题上，我们也不敢掉以轻心，所以就做了一个这样的测试。
测试环境是8核，64位机。用于测试的库是一个未经Sharding，大概30G左右的Collection。用于存储用户的喜好信息，标签信息等数据。
1library(rmongodb)
2
3mongo<-mongo.create()
4
5if(mongo.is.connected(mongo))
6{
7ns<-'rivendell.user'
8print('查询一个没有索引的字段，查询一条')
9print(system.time(p<-mongo.find.one(mongo,ns,list(Friend=600))))
10print('查询一个没有索引的字段，多条,withoutbuffer')
11print(system.time(p<-mongo.find(mongo,ns,list(Friend=600))))
12print('看看是否有缓存策略')
13print(system.time(p<-mongo.find(mongo,ns,list(Friend=600))))
14
15print('查询一个没有索引的字段，多条,hasbuffer')
16buf<-mongo.bson.buffer.create()
17mongo.bson.buffer.append(buf,'Friend',600L)
18query<-mongo.bson.from.buffer(buf)
19print(system.time(p<-mongo.find(mongo,ns,query)))
20print('看看是否有缓存策略')
21buf<-mongo.bson.buffer.create()
22mongo.bson.buffer.append(buf,'Friend',600L)
23query<-mongo.bson.from.buffer(buf)
24print(system.time(p<-mongo.find(mongo,ns,query)))
25
26print('大于的查询，查询一条记录')
27print(system.time(p<-mongo.find.one(mongo,ns,list(Friend=list('$gt'=600L)))))
28print('大于的记录，查询多条记录')
29print(system.time(cursor<-mongo.find(mongo,ns,list(Friend=list('$gt'=600L)))))
30mongo.cursor.destroy(cursor)
31
32print('查询一条有索引的记录')
33print(system.time(p<-mongo.find.one(mongo,ns,list('_id'=3831809L))))
34print('查询索引的记录')
35print(system.time(p<-mongo.find(mongo,ns,list('_id'=3831809L))))
36
37print('插入一条记录')
38buf<-mongo.bson.buffer.create()
39mongo.bson.buffer.append(buf,'name',"huangxin")
40mongo.bson.buffer.append(buf,'age',22L)
41p<-mongo.bson.from.buffer(buf)
42print(system.time(mongo.insert(mongo,ns,p)))
43
44print('找到刚刚插入的记录')
45print(system.time(p<-mongo.find.one(mongo,ns,list('name'='huangxin'))))
46if(!is.null(p))
47{
48print('success')
49}
50
51print('批量插入')
52
53buf<-mongo.bson.buffer.create()
54mongo.bson.buffer.append(buf,'name','huangxin')
55mongo.bson.buffer.append(buf,'age',22L)
56p1<-mongo.bson.from.buffer(buf)
57
58buf<-mongo.bson.buffer.create()
59mongo.bson.buffer.append(buf,'name','huangxin')
60mongo.bson.buffer.append(buf,'age',22L)
61p2<-mongo.bson.from.buffer(buf)
62
63buf<-mongo.bson.buffer.create()
64mongo.bson.buffer.append(buf,'name','huangxin')
65mongo.bson.buffer.append(buf,'age',22L)
66p3<-mongo.bson.from.buffer(buf)
67
68print(system.time(mongo.insert.batch(mongo,ns,list(p1,p2,p3))))
69
70print('找到刚刚批量插入的记录')
71print(system.time(cursor<-mongo.find(mongo,ns,list('name'='huangxin'))))
72
73i<-0
74while(mongo.cursor.next(cursor))
75{
76i<-i+1
77}
78print(i)
79
80print('批量更新')
81print(system.time(mongo.update(mongo,ns,list(name='huangxin'),list('name'='kym'))))
82
83print('查看更新是否成功')
84print(system.time(p<-mongo.find.one(mongo,ns,list('name'='kym'))))
85if(!is.null(p))
86{
87print('success')
88}
89
90print('批量删除')
91print(system.time(mongo.remove(mongo,ns,list(name='kym'))))
92}
93
94print(system.time(p<-mongo.find.one(mongo,ns,list('name'='kym'))))
95if(!is.null(p))
96{
97print('success')
98}
[1]"查询一个没有索引的字段，查询一条"
usersystemelapsed
0.0000.0000.115
[1]"查询一个没有索引的字段，多条,withoutbuffer"
usersystemelapsed
0.0000.00032.513
[1]"看看是否有缓存策略"
usersystemelapsed
0.0000.00032.528
[1]"查询一个没有索引的字段，多条,hasbuffer"
usersystemelapsed
0.0000.00032.685
[1]"看看是否有缓存策略"
usersystemelapsed
0.0000.00033.172
[1]"大于的查询，查询一条记录"
usersystemelapsed
0.0000.0000.001
[1]"大于的记录，查询多条记录"
usersystemelapsed
0.0000.0000.014
[1]"查询一条有索引的记录"
usersystemelapsed
000
[1]"查询索引的记录"
usersystemelapsed
000
[1]"插入一条记录"
usersystemelapsed
000
[1]"找到刚刚插入的记录"
usersystemelapsed
0.000.0035.42
[1]"success"
[1]"批量插入"
usersystemelapsed
000
[1]"找到刚刚批量插入的记录"
usersystemelapsed
0.0040.00035.934
[1]7
[1]"批量更新"
usersystemelapsed
0.0000.0040.000
[1]"查看更新是否成功"
usersystemelapsed
0.0000.00067.773
[1]"success"
[1]"批量删除"
usersystemelapsed
000
usersystemelapsed
0.0000.00091.396
之前我一直不太理解的就是为什么大于和等于，差距会差这么多。后来当我在用Python去做同样的测试的时候发现，Python两者的效率其实是相同的，所以这就证明了这个不是MongoDB的问题，而我不相信在数据库层面，一个语言的Driver会有这么大的差别。
后来我发现了Python和R的关于MongoDBDriver的一个区别。首先，Pythonfind的时候，不是将查询到的数据集整体拉回，而是返回一个cursor，也就是说，他在执行find命令的时候并不消耗时间，而如果加上whilecursor.next()的时候，才会真正地去执行这个查询。
但是R不一样，R会首先考虑数据集的大小（或者其他情况），然后视情况而定地返回cursor还是将整个数据集整体拉回。如果我们将之前的whilemongo.cursor.next(cursor)也算在计算时间的时候，那么我们就会发现，其实大于和等于的操作，效率相差并不明显了.......
在实际操作中，批量插入是一个非常常见的应用场景，但是对于R或者Matlab语言来说，循环的效率一直是硬伤，所以接下来，我会尝试着用apply系列来解决R语言的循环问题，如果实际操作发现可行，那么接下来使用mutilab等R的并行计算库来充分发挥多核的效率也值得尝试了！
本文内容总结：
原文链接：https://www.cnblogs.com/kym/archive/2011/09/26/2191501.html