你好,游客 登录 注册 搜索
背景:
阅读新闻

R对MongoDB的性能测试——RMongo

[日期:2013-03-15] 来源:  作者: [字体: ]

在九月初的时候,RMongoDB正式发布了修订版本,这也就意味着,从事数值计算的语言也可以于Nosql产品相接轨了,但是鉴于我身边并没有公司真的在使用R和MongoDB的结合,所以在效率问题上,我们也不敢掉以轻心,所以就做了一个这样的测试。

测试环境是8核,64位机。 用于测试的库是一个未经Sharding,大概30G左右的Collection。用于存储用户的喜好信息,标签信息等数据。

  1. library(rmongodb)   
  2.  
  3. mongo <- mongo.create()  
  4.  
  5. if(mongo.is.connected(mongo))  
  6. {  
  7.     ns <- 'rivendell.user' 
  8.     print('查询一个没有索引的字段,查询一条')  
  9.     print(system.time(p <- mongo.find.one(mongo,ns,list(Friend=600))))  
  10.     print('查询一个没有索引的字段,多条,without buffer')  
  11.     print(system.time(p <- mongo.find(mongo,ns,list(Friend=600))))  
  12.     print('看看是否有缓存策略')  
  13.     print(system.time(p <- mongo.find(mongo,ns,list(Friend=600))))  
  14.  
  15.     print('查询一个没有索引的字段,多条,has buffer')  
  16.     buf <- mongo.bson.buffer.create()  
  17.     mongo.bson.buffer.append(buf,'Friend',600L)  
  18.     query <- mongo.bson.from.buffer(buf)  
  19.     print(system.time(p <- mongo.find(mongo,ns,query)))  
  20.     print('看看是否有缓存策略')  
  21.     buf <- mongo.bson.buffer.create()  
  22.     mongo.bson.buffer.append(buf,'Friend',600L)  
  23.     query <- mongo.bson.from.buffer(buf)  
  24.     print(system.time(p <- mongo.find(mongo,ns,query)))  
  25.  
  26.     print('大于的查询,查询一条记录')  
  27.     print(system.time(p <- mongo.find.one(mongo,ns,list(Friend=list('$gt'=600L)))))  
  28.     print('大于的记录,查询多条记录')  
  29.     print(system.time(cursor <- mongo.find(mongo,ns,list(Friend=list('$gt'=600L)))))  
  30.     mongo.cursor.destroy(cursor)  
  31.  
  32.     print('查询一条有索引的记录')  
  33.     print(system.time(p <- mongo.find.one(mongo,ns,list('_id'=3831809L))))  
  34.     print('查询索引的记录')  
  35.     print(system.time(p <- mongo.find(mongo,ns,list('_id'=3831809L))))  
  36.  
  37.     print('插入一条记录')  
  38.     buf <- mongo.bson.buffer.create()  
  39.     mongo.bson.buffer.append(buf,'name',"huangxin")  
  40.     mongo.bson.buffer.append(buf,'age',22L)  
  41.     p <- mongo.bson.from.buffer(buf)  
  42.     print(system.time(mongo.insert(mongo,ns,p)))  
  43.  
  44.     print('找到刚刚插入的记录')  
  45.     print(system.time(p <- mongo.find.one(mongo,ns,list('name'='huangxin'))))  
  46.     if(!is.null(p))  
  47.     {  
  48.         print('success')  
  49.     }  
  50.  
  51.     print('批量插入')  
  52.  
  53.     buf <- mongo.bson.buffer.create()  
  54.     mongo.bson.buffer.append(buf,'name','huangxin')  
  55.     mongo.bson.buffer.append(buf,'age',22L)  
  56.     p1 <- mongo.bson.from.buffer(buf)  
  57.  
  58.     buf <- mongo.bson.buffer.create()  
  59.     mongo.bson.buffer.append(buf,'name','huangxin')  
  60.     mongo.bson.buffer.append(buf,'age',22L)  
  61.     p2 <- mongo.bson.from.buffer(buf)  
  62.  
  63.     buf <- mongo.bson.buffer.create()  
  64.     mongo.bson.buffer.append(buf,'name','huangxin')  
  65.     mongo.bson.buffer.append(buf,'age',22L)  
  66.     p3 <- mongo.bson.from.buffer(buf)  
  67.  
  68.     print(system.time(mongo.insert.batch(mongo,ns,list(p1,p2,p3))))  
  69.  
  70.     print('找到刚刚批量插入的记录')  
  71.     print(system.time(cursor <- mongo.find(mongo,ns,list('name'='huangxin'))))  
  72.  
  73.     i <- 0  
  74.     while(mongo.cursor.next(cursor))  
  75.     {  
  76.         i <- i + 1  
  77.     }  
  78.     print(i)  
  79.  
  80.     print('批量更新')  
  81.     print(system.time(mongo.update(mongo,ns,list(name='huangxin'),list('name''kym'))))  
  82.  
  83.     print('查看更新是否成功')  
  84.     print(system.time(p <- mongo.find.one(mongo,ns,list('name'='kym'))))  
  85.     if(!is.null(p))  
  86.     {  
  87.         print('success')  
  88.     }  
  89.  
  90.     print('批量删除')  
  91.     print(system.time(mongo.remove(mongo,ns,list(name='kym'))))  
  92. }  
  93.  
  94.     print(system.time(p <- mongo.find.one(mongo,ns,list('name'='kym'))))  
  95.     if(!is.null(p))  
  96.     {  
  97.         print('success')  
  98.     } 

 

  1. [1] "查询一个没有索引的字段,查询一条" 
  2. user system elapsed  
  3. 0.000 0.000 0.115  
  4. [1] "查询一个没有索引的字段,多条,without buffer" 
  5. user system elapsed  
  6. 0.000 0.000 32.513  
  7. [1] "看看是否有缓存策略" 
  8. user system elapsed  
  9. 0.000 0.000 32.528  
  10. [1] "查询一个没有索引的字段,多条,has buffer" 
  11. user system elapsed  
  12. 0.000 0.000 32.685  
  13. [1] "看看是否有缓存策略" 
  14. user system elapsed  
  15. 0.000 0.000 33.172  
  16. [1] "大于的查询,查询一条记录" 
  17. user system elapsed  
  18. 0.000 0.000 0.001  
  19. [1] "大于的记录,查询多条记录" 
  20. user system elapsed  
  21. 0.000 0.000 0.014  
  22. [1] "查询一条有索引的记录" 
  23. user system elapsed  
  24. 0 0 0  
  25. [1] "查询索引的记录" 
  26. user system elapsed  
  27. 0 0 0  
  28. [1] "插入一条记录" 
  29. user system elapsed  
  30. 0 0 0  
  31. [1] "找到刚刚插入的记录" 
  32. user system elapsed  
  33. 0.00 0.00 35.42  
  34. [1] "success" 
  35. [1] "批量插入" 
  36. user system elapsed  
  37. 0 0 0  
  38. [1] "找到刚刚批量插入的记录" 
  39. user system elapsed  
  40. 0.004 0.000 35.934  
  41. [1] 7  
  42. [1] "批量更新" 
  43. user system elapsed  
  44. 0.000 0.004 0.000  
  45. [1] "查看更新是否成功" 
  46. user system elapsed  
  47. 0.000 0.000 67.773  
  48. [1] "success" 
  49. [1] "批量删除" 
  50. user system elapsed  
  51. 0 0 0  
  52. user system elapsed  
  53. 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





收藏 推荐 打印 | 录入: | 阅读:
相关新闻