转 MongoDB数据库关系表示和设计:(1)嵌套文档和引用链接

本文涉及的产品
云数据库 MongoDB,通用型 2核4GB
简介:

使用数据的时候,一个数据项常常和另外的一个或多个数据项产生关系,比如一个“人”对象,有一个名字,可能有多个电话号码,以及多个子女,等等。

 

在传统的SQL数据库中,关系被分为一个个表(table),在表中,每个数据项以主键(primary key)标识,而一个表的主键又作为另一个表的外键(reference key),在两个表之间引用。当遇上多对多关系的时候,还需要一个额外的关联表(reference table),将多对多关系转化成两个一对多关系。

 

而在MongoDB中,表示关系有两种办法:

 

一种是嵌套(embedded),既是将一个文档包裹一个子文档;

 

而另一种是引用链接(reference link),使用MongoDB的DBRef对象建立文档和文档之间的关系。

 

除此之外,MongoDB的关系比起传统的SQL表关系更丰富一些,可以有 1对1 , 1对N , N对1 和 N对N 几种关系。

 

本文的目的就是探讨MongoDB表示关系的方法。

 

首先,让我们来看看MongoDB表示数据关系的两种方式:嵌套和引用链接。

 

嵌套

 

每个MongoDB文档都由BSON文档组成,有类似JSON格式一样的数据类型,其中String、Int、Float称为基本类型(或常量),而Hash和Array称之为复合类型。

 

所谓的嵌套,就是说文档中,利用复合类型,包裹一个多或多个其他类型的值,这些值称之为子文档。

 

文档嵌套的数量和深度没有限制,但MongoDB目前版本限制一个文档最大为16MB。

 

下面是一个典型的个人档案文档(profile),其中有一个 name 常量域,还嵌套了一个朋友(firends)子数组,数组里面每个项是一个字典。

 

Python代码    收藏代码
  1. >>> huangz  
  2. {'friends': [{'name''peter'}, {'name''john'}, {'name''marry'}], 'name''huangz'}  

 

嵌套的好处是显而易见的:嵌套文档维持了数据逻辑上的完整性,可以将一整项数据作为一个整体来操纵。

 

对比在关系式的数据库中, 为了设计出符合范式的表,我们常常要将多个数据项分拆为几个表,然后通过外键获取数据。

 

当你阅读一个单独的表的数据时,你通常只看到了其中一部分数据,而其他的都是外键id,就像这样:

 

Sql查询的输出代码    收藏代码
  1. ['name''huangz''friends_reference_id': [122630]]  

 

这种数据给人的感觉就像打开了一本电话簿,却发现里面只有电话号码,没有联系人姓名,真是太糟糕了阿。

 

 

引用链接

 

比起嵌套,引用链接更接近传统意义上的(也就是,关系型数据库术语中的)“引用”,它是两个文档之间的一种关系。

 

引用链接通过DBRef对象建立,DBRef对象储存了如何找到目标文档的信息,就像现实世界中的门牌号码一样(也类似关系型数据库中的外键)。

 

如果在一个文档A中,有一个DBRef对象,而这个DBRef对象储存了关于如何找到文档B的信息,那么文档A就可以通过解释这个DBRef对象(称之为解引用)来获取文档B的数据。

 

下面是建立一个文档的引用,以及解引用的过程,这次我们同样表示一个一对多的朋友关系,但这次,我们用链接来建立关系。

 

Python代码    收藏代码
  1. >>> # 数据  
  2. >>> peter = {'name':'peter'}  
  3. >>> marry = {'name':'marry'}  
  4. >>> john = {'name':'john'}  
  5. >>>  
  6. >>> # 插入数据  
  7. >>> c.test.people.insert([peter, john, marry])  
  8. [ObjectId('4e98075224b7d408dc000004'), ObjectId('4e98075224b7d408dc000005'), ObjectId('4e98075224b7d408dc000006')]  
  9. >>>  
  10. >>> # 建立huangz文档,以及指向各个朋友的链接  
  11. >>> huangz = {'name''huangz',  
  12. ...     'friends': [ DBRef('people', peter['_id']),  
  13. ...                  DBRef('people', john['_id']),  
  14. ...                  DBRef('people', marry['_id']) ]}  
  15. >>>  
  16. >>> c.test.people.insert(huangz)  
  17. ObjectId('4e9807d924b7d408dc000007')  
  18. >>>  
  19. >>> # 查看huangz文档  
  20. >>> huangz  
  21. {'_id': ObjectId('4e9807d924b7d408dc000007'), 'friends': [DBRef('people', ObjectId('4e98075224b7d408dc000004')), DBRef('people', ObjectId('4e98075224b7d408dc000005')), DBRef('people', ObjectId('4e98075224b7d408dc000006'))], 'name''huangz'}  
  22. >>>  
  23. >>> # 对friends中的所有域进行解引用  
  24. >>> [ c.test.dereference(friend) for friend in huangz['friends'] ]  
  25. [{u'_id': ObjectId('4e98075224b7d408dc000004'), u'name': u'peter'}, {u'_id': ObjectId('4e98075224b7d408dc000005'), u'name': u'john'}, {u'_id': ObjectId('4e98075224b7d408dc000006'), u'name': u'marry'}]  
  

OK,虽然有点复杂,但相信聪明的你还是可以看出,我建立了三个字典(Dict,或者说,Hash?)文档,将它们插入people集合。

 

然后使用 BDRef 函数,将集合名和字典的 id 作为参数,对每个字典生成一个 DBRef 对象,然后将三个DBRef对象保存到 friends 域当中。

 

在最后,我遍历 huangz 文档中的 friends 域,将所有 DBRef 对象解引用,获取了三个相应的子文档。

 

-----

 

附录

 

引用和解引用的API:

 

http://api.mongodb.org/python/current/api/pymongo/database.html?highlight=dereference#pymongo.database.Database.dereference

 

http://api.mongodb.org/python/current/api/bson/dbref.html#bson.dbref.DBRef

 

关于DBRef的官方文档:

 

http://www.mongodb.org/display/DOCS/Database+References

 

 

自动解引用

 

目前为止,我们看过了嵌套和引用链接两种使用子文档的方式,但是,慢着,嵌套和引用链接的区别是什么?

 

它们最大的区别似乎在于麻烦程度——嵌套文档可以直接使用子文档中的数据,而引用链接则要先解引用,然后才能获取子文档的数据。

 

如果你也觉得解引用相当麻烦的话,那我有一个好消息要告诉你:pymongo有一个超方便的特性,称之为“自动解引用”,就是每当 pymongo 在你文档中的数据域中发现包含有 DBRef 对象,你忠实的好朋友 pymongo 就会自动帮你进行解引用,你一个手指头都不用动!

 

看看使用自动解引用情况下,之前的 friends 例子:

 

Python代码    收藏代码
  1. >>> from pymongo.connection import Connection  
  2. >>> # 自动解引用所需的函数  
  3. >>> from pymongo.son_manipulator import AutoReference, NamespaceInjector  
  4. >>>  
  5. >>> # 连接数据库,并选择 test 数据库作为储存  
  6. >>> c = Connection()  
  7. >>> db = c.test  
  8. >>>  
  9. >>> # 魔法发生的地方。。。  
  10. >>> db.add_son_manipulator(NamespaceInjector())  
  11. >>> db.add_son_manipulator(AutoReference(db))  
  12. >>>   
  13. >>> # 数据  
  14. >>> peter = {'name''peter'}  
  15. >>> john = {'name''john'}  
  16. >>> marry = {'name''marry'}  
  17. >>>  
  18. >>> # 将数据插入数据库  
  19. >>> db.people.insert([peter, john, marry])  
  20. [ObjectId('4e980fe824b7d41f52000000'), ObjectId('4e980fe824b7d41f52000001'), ObjectId('4e980fe824b7d41f52000002')]  
  21. >>>  
  22. >>> # huangz 文档  
  23. >>> huangz = {'name''huangz',   
  24. ...           'friends': [peter, john, marry]}  
  25. >>> db.people.insert(huangz)  
  26. ObjectId('4e98104324b7d41f52000003')  
  27. >>>  
  28. >>> # 看一看,文档里多了一些奇怪的东西。。。嗯。。。  
  29. >>> huangz  
  30. {'_ns': u'people''_id': ObjectId('4e98104324b7d41f52000003'), 'friends': [{'_ns': u'people''_id': ObjectId('4e980fe824b7d41f52000000'), 'name''peter'}, {'_ns': u'people''_id': ObjectId('4e980fe824b7d41f52000001'), 'name''john'}, {'_ns': u'people''_id': ObjectId('4e980fe824b7d41f52000002'), 'name''marry'}], 'name''huangz'}  
  31. >>>   
  32. >>> # 试试提取 friends 域中的数据(注意这里我们没有手动进行解引用)  
  33. >>> huangz['friends'][0]  
  34. {'_ns': u'people''_id': ObjectId('4e980fe824b7d41f52000000'), 'name''peter'}  
  35. >>>  
  36. >>> # wow,解引用自动完成了!再试试  
  37. >>> huangz['friends'][0]['name']  
  38. 'peter'  
  39. >>>  
  40. >>> # 这里你可能会疑惑,我们是不是使用嵌套将数据放进了huangz文档里面,而实际上没有使用引用?  
  41. >>> # 答案是,不是的,我们使用了引用,看看 peter 文档,它有一个id  
  42. >>> # 证明 peter 文档是一个独立文档,而不是一个嵌入文档:  
  43. >>> peter  
  44. {'_ns': u'people''_id': ObjectId('4e980fe824b7d41f52000000'), 'name''peter'}  
  45. >>>  
  46. >>> # 如果你还是不信,我们可以试试修改 peter 文档,然后再保存  
  47. >>> # 看看 huangz 文档里面的 peter,是否会变化  
  48. >>> peter['name'] = 'peter Liu'  
  49. >>> db.people.save(peter)  
  50. ObjectId('4e980fe824b7d41f52000000')  
  51. >>>  
  52. >>> # 哈,huangz 文档里面的 peter 也发生了变化,证明我们使用的  
  53. >>> # 是引用而不是嵌套,嘿,我可是童叟无欺、信誉良好的阿。  
  54. >>> huangz['friends'][0]['name']  
  55. 'peter Liu'  
 

在上面的代码中,我们增加了两个函数,为 db 绑定了两个构造器,从那之后,解引用就魔术般自动完成了。

 

好,这样一来,使用嵌套文档和使用引用链接似乎就没有什么不同了。

 

嘿嘿,现在我要问你一个严肃的问题了:使用嵌套文档和链接文档,究竟有什么不同?

 

请你尽可能地独立思考一下,然后再继续阅读下一节。

 

-----

 

附录

 

自动解引用的例子:

 

https://github.com/mongodb/mongo-python-driver/blob/cd47b2475c5fe567e98696e6bc5af3c402891d12/examples/auto_reference.py

 

 

嵌套 v.s. 引用链接

 

终于来到了谜底揭开的时刻了!如果答案你自己没想出来,也不用心灰意冷,毕竟我就是来告诉你这个的,如果你自己把答案想出来了,这反而没有意思了不是么?

 

关于嵌套和引用链接的真正区别是——它们的名字是不同的!

 

好吧,你一定已经知道这个了,其实,关于嵌套和引用链接的真正却别是——它们的英文名字是不同的!

 

好吧,你一定也已经知道了这个,那我们来说点严肃的。

 

嵌套和引用链接的区别在于,它们对待其他文档(子文档)的方式不同,于是它们获取获取子文档数据的方式也不同。

 

先来看嵌套,当我们将一个子文档,比如 friends 数组(它本身也是一个单独的文档)嵌套于 huangz 文档时, friends 文档其实和 huangz 文档是一体的,其实它们是一个文档,它们的数据储存在一起。

 

而对于引用链接,当你取出一个包含引用链接的文档时,文档里面的 DBRef 对象不会被解开,你取出的是一个包含 DBRef对象的子文档。而那些 DBRef 对象所指向的文档,它们是独立的一个个文档,从某个角度来看,和这个文档没有任何关系。(你对自动解引用感到疑惑么,我马上就会说到这个,请稍等。)

 

因此,每次,当你对DBRef执行解引用的时候,你需要一次额外的查询。

 

啊哈,这就是嵌套和引用链接之间的区别了!

 

我们用两个文档,一个嵌套,一个引用链接,解释查找它们的过程,来说明它们之间的区别。

 

先说嵌套文档,这个文档如下(跟我们之前看的一样):

 

Python代码    收藏代码
  1. >>> peter = {'name''peter'}  
  2. >>> john = {'name''john'}  
  3. >>> marry = {'name''marry'}  
  4. >>>  
  5. >>> huangz = {'name''huangz''friends': [peter, john, marry]}  
  6. >>>  
  7. >>> people.insert(huangz)  
  8. ObjectId('4e98e30b24b7d40a53000002')  
  9. >>>  
  10. >>> huangz  
  11. {'_id': ObjectId('4e98e30b24b7d40a53000002'), 'friends': [{'name''peter'}, {'name''john'}, {'name''marry'}], 'name''huangz'}  

 

我们可以用 huangz 文档的 id 作为条件,查找 huangz 文档:

 

Python代码    收藏代码
  1. >>> people.find_one({'_id': huangz['_id']})  
  2. {u'_id': ObjectId('4e98e30b24b7d40a53000002'), u'friends': [{u'name': u'peter'}, {u'name': u'john'}, {u'name': u'marry'}], u'name': u'huangz'}  

 

当执行上面的语句时,MongoDB会根据 id ,查找文档,它在数据库内部苦苦找寻,然后,终于找到了你所需的文档。

 

于是MongoDB就将文档返回给你,因为整个 huangz 文档——包括 name 数据域和 friends 数据域都放在一起,所以,执行这个文档只需要一次数据库查询,嗯,就是这样。

 

接着再来看看带有引用链接的文档是怎么处理的:

 

Java代码    收藏代码
  1. >>> peter = {'name''peter'}  
  2. >>> john = {'name''john'}  
  3. >>> marry = {'name''marry'}  
  4. >>>  
  5. >>> people.insert([peter, john, marry])  
  6. [ObjectId('4e98e41b24b7d40a53000003'), ObjectId('4e98e41b24b7d40a53000004'), ObjectId('4e98e41b24b7d40a53000005')]  
  7. >>>  
  8. >>> huangz = {'name''huangz',  
  9. ...           'friends': [ DBRef('people', peter['_id']),  
  10. ...                        DBRef('people', john['_id']),  
  11. ...                        DBRef('people', marry['_id']) ] }  
  12. >>> people.insert(huangz)  
  13. ObjectId('4e98e4da24b7d40a53000006')  

 

当我查找 huangz 文档时,会发生些什么?

 

Python代码    收藏代码
  1. >>> people.find_one({'_id': huangz['_id']})  
  2. {u'_id': ObjectId('4e98e4da24b7d40a53000006'), u'friends': [DBRef(u'people', ObjectId('4e98e41b24b7d40a53000003')), DBRef(u'people', ObjectId('4e98e41b24b7d40a53000004')), DBRef(u'people', ObjectId('4e98e41b24b7d40a53000005'))], u'name': u'huangz'}  

 

你的老朋友MongoDB(现在你们应该很熟悉了)接到你的查询任务,然后开始在数据库再次苦苦寻找,然后,终于找到你需要的文档,于是,MongoDB返回这个文档。

 

寻找这个文档也只需要一次数据库查询(暂时和嵌套文件一样),但是,请注意,这个文档和之前的嵌套文档不同,它包含的不是你所需要的数据,而是 DBRef 对象,三个 DBRef 对象分别储存了如何去找到 peter、jhon 和 marry 文档的信息,但它们本身还不是你所找的数据(还记得那个只有号码没有姓名的电话簿吗?)。

 

“嘿,我们有 dereference 函数,可以用它进行解引用”,我猜你在这么想——你说得对,我们可以对 huangz 文档里的 friends 数据域中的三个 DBRef 文档进行解引用:

 

Python代码    收藏代码
  1. >>> for friend in huangz['friends']:  
  2. ...     db.dereference(friend)  
  3. ...   
  4. {u'_id': ObjectId('4e98e41b24b7d40a53000003'), u'name': u'peter'}  
  5. {u'_id': ObjectId('4e98e41b24b7d40a53000004'), u'name': u'john'}  
  6. {u'_id': ObjectId('4e98e41b24b7d40a53000005'), u'name': u'marry'}  

 

然后,慢着,在解引用的过程中,发生了什么呢?

 

首先,MongoDB接到第一个 DBRef 文件,上面指名我们所找的文档的 id 和 集合,于是乎,MongoDB就根据这个地址,去帮我们搜索 id 为 '4e98e41b24b7d40a53000003' 的文档,它苦苦找寻,终于发现了 peter 文档,于是,它将 peter 文档返回给你,这个过程需要一个数据库查询。

 

然后,MongoDB 接到第二个 DBRef 文件,上面又有一个新地址,于是 MongoDB 根据这个地址又开始查找,一阵搜索之后,它找到了 john 文档,并返回给你,这个过程又需要一个数据库查询。

 

再次,MongoDB 接到第三个 DBRef 文件,上面又有一个新地址,不辞劳苦的 MongoDB 再一次开始工作,这次,它找到并将 marry 文档返回给你,这个过程又需要一个数据库查询。

 

最终,你使用引用链接的文档获得了和嵌套文档一样的数据,但引用链接的文档使用了 4 次数据库查询(一次 huangz 文档,peter、john 和 marry各一次),而嵌套文档只使用 1 次数据库查询。

 

噢噢噢,你有种忽然明白了一些什么的感觉,是吗?

 

 

结论

 

OK,这时候,我们差不多该下结论说,为了最大效率地使用数据库,你应该尽可能地使用嵌套而不是引用链接来设计你的MongoDB文档,因为每次解引用都会带来一次额外的搜索,它的速度比使用嵌套的文档慢的多(取决于解引用的次数)。

 

但是还有几个微妙的问题,在下结论之前,需要好好地解释一下:

 

1. 自动解引用和手动解引用的效率是否不同?

 

答案是,自动解引用和手动解引用的效率是一样的,它们使用相同的数据库查询次数,

 

当你启用了自动解引用之后,pymongo每次发现你取出的文档里面带有 DBRef 对象时,它就帮你调用 deference 函数,获得 DBRef 所指向的文档的数据,但是,它不会也不可能将 4 次数据库查询换成 1 次数据库查询。

 

2. 使用引用链接,对效率的影响有多大?

 

答:一个包含引用链接文档所需的数据库查询次数正比于解引用的次数 + 1(获取这个文档本身),而所需的查询次数越多,就越慢。

 

像上面 huangz 文档的例子,引用链接版本理论上需要的时间就是嵌套版本的 3 倍。

 

3. 似乎嵌套文档真不错,但如果我有一个 weibo 文档(一个微博文档),它包括 name 和 message,两个数据域。


message 就是储存微博的数据域,而 name 则是用户名字,message 数据域肯定会比 name 数据域大很多,那么,这个 weibo 文档取出的速度,会受到 message 数据域的大小影响吗,name 数据域呢?

 

答:这的确是使用嵌套文档需要小心的地方,因为整个文档可能很大,如果你不小心使用查询语句,确保只取出必须的数据的话,你可能会浪费一些时间读取不必要的字段。

 

比如,以微薄为例子,假如你使用下面这个查询语句,所有属于 huangz 的微薄都会被取出来,这可能不是你想要的结果(比如文档里有 10万 条数据,但你只想取出前 100 条,那样的话,其他 9900 条数据都被浪费了)。

 

Python代码    收藏代码
  1. data = weibo.find_one({'name''huangz'})  

 

而换成以下数据,你可以只取出最新100条数据,不浪费任何资源:

 

Python代码    收藏代码
  1. data = weibo.find_one({'name''huangz'}, {'message': {'$slice': -100}})  

 

(你可能发现这个查询语句还是有一些问题,嗯,的确是这样,因为它取出来的数据是倒转过来的,也即是,最新发的微薄在最低下,我们以后再来解决这个问题。)

 

如果你在看别人的微薄,那时候你一条信息都不需要取出来,你只需要其他个人信息,比如 name,所以,你应该使用以下语句:

 

Python代码    收藏代码
  1. data = weibo.find_one({'name''huangz'}, {'message: 0})  

 

实际上,使用引用连接的文档也有这个问题,而且比嵌套文档的情况更严重(因为它更慢)。

 

所以,无论什么情况下,请确保你使用了正确的查询语句,确保只取出所需的数据。

 

4.如果我先用一个查询取出一个嵌套文档的某一部分,再用另一个查询取出这个嵌套文档的另一部分,这比使用一个引用链接的文档快吗?

 

答:不,因为它们都需要两次数据库查询,效果相差无几。

 

---

 

附录

 

子域查询的语法 http://www.mongodb.org/display/DOCS/Retrieving+a+Subset+of+Fields

 

 

时间关系。。。

 

好了,这时候,你应该对“使用嵌套文档加上合理的查询,可以获得最高效率”这一结论深信不疑了。

 

嘿嘿,但我有个坏消息要告诉你,就是并不是所有文档关系都能使用嵌套文档来设计,有时候,必须用到引用链接。

 

不过,因为时间关系,以及为了点击量的可持续发展,我决定把这个问题和剩下的内容(1对1、1对N等关系设计和示例)留到下一篇博客再写。

附录

 

MongoDB schema design  http://www.mongodb.org/display/DOCS/Schema+Design#SchemaDesign-EmbeddingandLinking


原文地址:http://huangz.iteye.com/blog/1196185

相关实践学习
MongoDB数据库入门
MongoDB数据库入门实验。
快速掌握 MongoDB 数据库
本课程主要讲解MongoDB数据库的基本知识,包括MongoDB数据库的安装、配置、服务的启动、数据的CRUD操作函数使用、MongoDB索引的使用(唯一索引、地理索引、过期索引、全文索引等)、MapReduce操作实现、用户管理、Java对MongoDB的操作支持(基于2.x驱动与3.x驱动的完全讲解)。 通过学习此课程,读者将具备MongoDB数据库的开发能力,并且能够使用MongoDB进行项目开发。   相关的阿里云产品:云数据库 MongoDB版 云数据库MongoDB版支持ReplicaSet和Sharding两种部署架构,具备安全审计,时间点备份等多项企业能力。在互联网、物联网、游戏、金融等领域被广泛采用。 云数据库MongoDB版(ApsaraDB for MongoDB)完全兼容MongoDB协议,基于飞天分布式系统和高可靠存储引擎,提供多节点高可用架构、弹性扩容、容灾、备份回滚、性能优化等解决方案。 产品详情: https://www.aliyun.com/product/mongodb
相关文章
|
12天前
|
NoSQL 关系型数据库 MySQL
Windows、Linux、Mac安装数据库(mysql、MongoDB、Redis)#0
不同系统下进行MySQL安装、MongoDB安装、Redis安装
55 5
Windows、Linux、Mac安装数据库(mysql、MongoDB、Redis)#0
|
15天前
|
关系型数据库 MySQL 测试技术
Eolink神技之一、基于数据库智能生成API文档
Eolink神技之一、基于数据库智能生成API文档
13 0
Eolink神技之一、基于数据库智能生成API文档
|
22天前
|
存储 JSON NoSQL
【MongoDB】<文档型数据库>Windows&Liunx安装MongoDB(无错完整)
【1月更文挑战第26天】【MongoDB】<文档型数据库>Windows&Liunx安装MongoDB(无错完整)
|
22天前
|
关系型数据库 MySQL PHP
|
26天前
|
C# 数据库 数据库管理
C#使用Poco链接SQLite数据库配置文件和错误的解决
C#使用Poco链接SQLite数据库配置文件和错误的解决
13 1
|
27天前
|
机器学习/深度学习 自然语言处理 NoSQL
|
1月前
|
关系型数据库 MySQL 网络安全
navicat链接腾讯云上的数据库mysql 8.0(可行方案)
navicat链接腾讯云上的数据库mysql 8.0(可行方案)
22 0
|
1月前
|
存储 NoSQL MongoDB
请解释一下文档存储数据库的工作原理,并提供一个使用文档存储数据库的实际应用场景。
请解释一下文档存储数据库的工作原理,并提供一个使用文档存储数据库的实际应用场景。
29 0
|
1月前
|
存储 JSON NoSQL
在官网免费创建一个云mongoDB数据库
MongoDB的设计目标是提供高性能、高可用性、可扩展性和易用性。它采用了文档存储模型,将数据以类似JSON的BSON(Binary JSON)格式存储,并且支持动态模式,允许应用程序更灵活地存储和查询数据。MongoDB还支持水平扩展,可以在集群中添加更多的节点以处理更大的数据量和请求负载。
45 0
|
1月前
|
关系型数据库 MySQL Go
go语言使用Gin框架链接数据库
go语言使用Gin框架链接数据库
17 0

热门文章

最新文章