mongoDB的查询测试
做的事情:
分析mongodb的查询性能，引入冗余的字段来加快查询的效率是否可行？同时对比了冗余字段和索引的查询能力。
我们从下面几个维度来分析
1. 存储空间
2. 时间
怎么做：
1. 生成数据
2. 分两类来考察
a. 冗余一定的数据来加快数据本身的子父级关系
b. 建立索引的方式
3. 统计数据库的空间成本，查询花费的时间成本
举例：
1. 数据结构如下：
{"id"：1, "data":"adasdasd","parent":2}
{"id"：2, "data":"adasdasd","parent":null}
2. 数据结构如下：
{"id":1 , "data":"asdasdasd","children":[2,3],"parent":null}
{"id":2 , "data":"asdasdasd","children":[],"parent":2}
我们要查询的数据是：将一条数据的子数据都查询出来
第一种查询方式
db.test1.find({"parent":2})
第二种查询方式:
db.test2.find({"$in":{"_id":[2,3,4]}})
第三种查询方式和第一种一样，只是第三种多了一个parent_id 的索引
1. 首先我们先要创建数据库和数据
import random
defget_id(db):
key = db.seq.find_and_modify(
query={'name':'mongo_test'},
update={'$inc': {'seq':1}}
)
if notkey:
db.seq.insert({"name":"mongo_test","seq":1})
return 1
returnkey['seq']
def init_data(client):
""" 构造数据 """
db1 = client["mongo_test1"]
db2 = client["mongo_test2"]
for i in xrange(100000):
key1 = get_id(db1)
parent_id = None
if random.random() > 0.2:
parent_id = random.randint(1, i + 1)
data = {"_id": key1, "data": "And loved your beauty with love false or true {0}".format(i),"parent_id": parent_id}
db1.mongo_test.insert(data)
key2 = get_id(db2)
data2 = {"_id": key2, "data": "And loved your beauty with love false or true {0}".format(i), "children_id": [],"parent_id": parent_id}
db2.mongo_test.insert(data2)
if parent_id:
parent = db2.mongo_test.find_one({"_id": parent_id})
if parent and parent.get("parent_id") is None:
children = parent.get("children_id", [])
children.append(key2)
db2.mongo_test.save(parent)
if i % 10000 == 0:
print "{0}0 % ".format(i // 10000)
这个方法就是在创建数据，数据量在100000条。
2. 数据生成完了之后，我们需要到mongo客户端copy一个数据出来，命名为mong_test3，这个数据库和mong_test1数据库唯一的区别在于，我们会再mong_test3中添加一个parent_id 的索引
db.copyDatabase('mongo_test1', 'mongo_test3', '127.0.0.1');
use mongo_test3
db.mongo_test.ensureIndex( { 'patent_id' : 1 } )
3. 上两步完成之后就开始查询数据，并且计算查找时间
def test_db(client):
"""测试花费的时间"""
db1 = client["mongo_test1"]
import time
start = time.time()
parent = db1.mongo_test.find({"parent": None})
for item in parent:
children = db1.mongo_test.find({"parent_id": item.get("_id")})
end = time.time()
test_db1_time = end - start
db2 = client["mongo_test2"]
start = time.time()
parent = db2.mongo_test.find({"parent": None})
for item in parent:
if item.get("children_id"):
children = db2.mongo_test.find({"_id": {"$in": item.get("children_id",[])}})
end = time.time()
test_db2_time = end - start
db3 = client["mongo_test3"]
start = time.time()
parent = db3.mongo_test.find({"parent": None})
for item in parent:
children = db3.mongo_test.find({"parent_id": item.get("_id")})
end = time.time()
test_db3_time = end - start
print "第一种方式花费时间：{0} \n" \
"第二种方式花费时间：{1} \n" \
"第三种方式花费时间(parent建立索引)：{2}".format(test_db1_time, test_db2_time, test_db3_time)
4. 最后展示一张我查找的结果截图：
可以看出来，有索引的情况确认会比没有缩影的情况在查询时间上还一点，但是没有那么突出的效果。
而我冗余的children_id 数组却带来了4倍的查询速度的提升 ，可以说是效果非常的明显了。
5. 我们来查看一下他们空间大小：
查询后发现，他们的区别在这个10W的数据量下表现不出来。
6. 主函数：
if __name__ == '__main__':
from pymongo import MongoClient
client = MongoClient(host='127.0.0.1', port=27017)
init_data(client)
# test_db(client)
注意：
在我们执行添加数据操作的时候，会报两次错误，这是由于数据库数据引起的。不用在意，点击执行就好了，大概要点击三次，在第三次的时候就不会再报错了。
总结：
这是一个典型的用空间换时间的例子。
我们这里还没有去考虑建立索引带来了插入和删除的性能损耗的问题，只是单纯的做了一次查找的性能对比。
至此，在这个10W的数据量下的查询冗余字段完胜普通方法和索引。
完整的代码就是将上面的代码依次放入py文件中，就可以执行了。前提是本地机器上已经有了mongoDB数据库。
