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